{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "24c88602",
   "metadata": {},
   "source": [
    "## SAC_Pendulum-v1\n",
    "\n",
    "SAC（Soft Actor-Critic）有两个版本，其中[SAC-v1](https://arxiv.org/abs/1801.01290)由Haarnoja等人于2018年提出，也是该算法的最初版本, [SAC-v2](https://arxiv.org/abs/1812.05905)则是于2019年提出的改进版本。其中相比于v1版本，SAC-v2主要做了两项重要改进，一是移除了Value网络，二是引入了自动调节entropy系数 $\\alpha$。\n",
    "\n",
    "由于目前主流使用的是V2版本，因此未特别说明的情况下，我们默认实现v2版本, 例如本Notebook。相比v1版本，v2版本主要去掉了Value网络，以及使用的双Q(cirtic)网络。\n",
    "\n",
    "v1版本中Value网络主要充当Actor 和 Critic 网络训练之间的桥梁，但是增加一个这样的网络会导致更多误差传播路径，并且其实可以这样构造Q的目标函数，更稳定更直接：\n",
    "\n",
    "$$\n",
    "r+\\gamma \\cdot\\left(\\min \\left(Q_1^{\\prime}, Q_2^{\\prime}\\right)-\\alpha \\log \\pi\\left(a^{\\prime} \\mid s^{\\prime}\\right)\\right)\n",
    "$$\n",
    "\n",
    "而双Q网络的作用，就跟Double DQN、TD3算法类似，多一个critic来减缓Q值的过估计。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b892e72",
   "metadata": {},
   "source": [
    "### 定义参数\n",
    "\n",
    "为方便实验调试，把所有参数都放在一起"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "c11c4d5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.algo_name = 'SAC'\n",
    "        self.env_id = 'CartPole-v1'\n",
    "        self.mode = 'train'\n",
    "        self.seed = 0 # 随机种子\n",
    "        self.max_epsiode = 100 # 训练的回合数\n",
    "        self.max_step = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        #region 在线测试相关参数\n",
    "        self.online_eval_episode = 10 # 测试的回合数\n",
    "        self.online_eval_freq = 2000 # 在线测试的频率, 模型每更新N次就测试一次\n",
    "        #endregion\n",
    "        self.gamma = 0.99 #折扣因子\n",
    "        self.lambda_mean=1e-3 # 重参数化分布均值的损失权重\n",
    "        self.lambda_std=1e-3 # 重参数化分布标准差的损失权重\n",
    "        self.lambda_z = 0.0 # 重参数化分布抽样值的损失权重\n",
    "        self.soft_update_tau = 1e-2 # 目标网络软更新系数\n",
    "        self.lr_critic = 3e-4 # Q网络的学习率\n",
    "        self.lr_actor = 3e-4 # 策略网络的学习率\n",
    "        self.lr_alpha = 3e-4 # 温度参数的学习率\n",
    "        self.buffer_size = 8000 # 经验回放池大小\n",
    "        self.hidden_dim = 256 # 隐藏层维度\n",
    "        self.batch_size  = 128 # 批次大小\n",
    "        self.device = self._auto_get_device() # 设备\n",
    "    \n",
    "    def _auto_get_device(self):\n",
    "        _device = 'cpu'\n",
    "        if torch.cuda.is_available():\n",
    "            _device = 'cuda'\n",
    "        elif torch.backends.mps.is_available():\n",
    "            _device = 'mps'\n",
    "        return _device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "377edc7d",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "去掉了Value网络之后，SAC-v2版本就是一个经典的Actor-Critic结构了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "6218efae",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.optim import Adam\n",
    "from torch.distributions import Normal\n",
    "import numpy as np\n",
    "\n",
    "        \n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim, hidden_dim, init_w=3e-3):\n",
    "        super(Critic, self).__init__()\n",
    "        '''SoftQ\n",
    "        '''\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(state_dim, hidden_dim), nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, hidden_dim), nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, action_dim)\n",
    "        )\n",
    "        \n",
    "    def forward(self, state):\n",
    "        return self.layers(state)\n",
    "        \n",
    "        \n",
    "class Actor(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim, hidden_dim):\n",
    "        super(Actor, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(state_dim, hidden_dim), nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, hidden_dim), nn.ReLU(),\n",
    "            nn.Linear(hidden_dim, action_dim)\n",
    "        )\n",
    "        \n",
    "    def forward(self, state):\n",
    "        logits = self.layers(state)\n",
    "        probs = torch.softmax(logits, dim=-1)\n",
    "        log_probs = torch.log_softmax(logits, dim=-1)\n",
    "        return probs, log_probs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "debce530",
   "metadata": {},
   "source": [
    "### 定义经验回放\n",
    "\n",
    "经验回放主要有两个功能，一是存储样本(push)，二是随时采样样本(sample)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "1c740ca0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, cfg: Config) -> None:\n",
    "        self.capacity = cfg.buffer_size\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "        \n",
    "    def push(self, transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "        \n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32a65b71",
   "metadata": {},
   "source": [
    "### 定义策略\n",
    "\n",
    "SAC-v1 的value网络包含主网络和目标网络，起作用跟`DQN`中的 $Q$ 和 $Q_target$ 网络是一样的，都是为了避免估计目标Q值的剧烈波动，使得训练更加稳定。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "5a86f725",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Policy:\n",
    "    def __init__(self, cfg: Config, state_dim:int, action_dim:int) -> None:\n",
    "\n",
    "        self.batch_size  = cfg.batch_size \n",
    "        \n",
    "        self.device = torch.device(cfg.device)\n",
    "        self.gamma = cfg.gamma\n",
    "        self.lambda_mean = cfg.lambda_mean\n",
    "        self.lambda_std  = cfg.lambda_std\n",
    "        self.lambda_z    = cfg.lambda_z\n",
    "        self.soft_update_tau = cfg.soft_update_tau\n",
    "\n",
    "        # 双Q网络\n",
    "        self.critic_1 = Critic(state_dim, action_dim, cfg.hidden_dim).to(self.device)\n",
    "        self.critic_2 = Critic(state_dim, action_dim, cfg.hidden_dim).to(self.device)\n",
    "        self.critic_1_target = Critic(state_dim, action_dim, cfg.hidden_dim).to(self.device)\n",
    "        self.critic_2_target = Critic(state_dim, action_dim, cfg.hidden_dim).to(self.device)\n",
    "        self.critic_1_target.load_state_dict(self.critic_1.state_dict())\n",
    "        self.critic_2_target.load_state_dict(self.critic_2.state_dict())\n",
    "\n",
    "        self.actor = Actor(state_dim, action_dim, cfg.hidden_dim).to(self.device)  \n",
    "\n",
    "        self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device)\n",
    "\n",
    "        self.opt_critic_1 = Adam(self.critic_1.parameters(), lr=cfg.lr_critic)\n",
    "        self.opt_critic_2 = Adam(self.critic_2.parameters(), lr=cfg.lr_critic)\n",
    "        self.opt_actor = Adam(self.actor.parameters(), lr=cfg.lr_actor)  \n",
    "        self.opt_alpha = Adam([self.log_alpha], lr=cfg.lr_alpha) # 学习率和actor相同\n",
    "\n",
    "        self.target_entropy = -np.log(1.0 / action_dim) * 0.98\n",
    "\n",
    "        self.memory = ReplayBuffer(cfg)\n",
    "\n",
    "        self.update_cnt = 0\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def sample_action(self, state):\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        probs, _ = self.actor(state)\n",
    "        dist = torch.distributions.Categorical(probs)\n",
    "        action = dist.sample().item()\n",
    "        return action\n",
    "    \n",
    "    @torch.no_grad()\n",
    "    def predict_action(self, state):\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        probs, _ = self.actor(state)\n",
    "        action = torch.argmax(probs, dim=1).item()\n",
    "        return action\n",
    "    \n",
    "    def get_policy_params(self):\n",
    "        '''获取策略网络的参数\n",
    "        '''\n",
    "        return self.actor.parameters()\n",
    "    \n",
    "    def set_policy_params(self, params):\n",
    "        '''设置策略网络的参数\n",
    "        '''\n",
    "        for param, new_param in zip(self.actor.parameters(), params):\n",
    "            param.data.copy_(new_param.data)\n",
    "        \n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return \n",
    "        states, actions, rewards, next_states, dones = self.memory.sample(self.batch_size) # 从经验回放中随机采样一个批量的转移(transition)\n",
    "        # 将数据转换为tensor\n",
    "        states = torch.tensor(np.array(states), device = self.device, dtype=torch.float) # [B, state_dim]\n",
    "        actions = torch.tensor(np.array(actions), device=self.device,  dtype = torch.int64).unsqueeze(1)  #  [B, 1]\n",
    "        rewards = torch.tensor(rewards, device=self.device, dtype=torch.float).unsqueeze(1)   # [B, 1]\n",
    "        next_states = torch.tensor(np.array(next_states), device=self.device, dtype=torch.float) # [batchB_size, state_dim]\n",
    "        dones = torch.tensor(np.float32(dones), device=self.device).unsqueeze(1)  # [batch_size,1]\n",
    "\n",
    "        with torch.no_grad():    \n",
    "            probs_next, log_probs_next = self.actor(next_states) #计算t+1时刻的动作\n",
    "            q_value_1_target = self.critic_1_target(next_states) #计算t+1时刻的q值\n",
    "            q_value_2_target = self.critic_2_target(next_states)\n",
    "            q_value_min = torch.min(q_value_1_target, q_value_2_target) # 计算t+1时刻的q值\n",
    "            entropy = -torch.sum(log_probs_next * log_probs_next, dim=1, keepdim=True)\n",
    "            q_value_target = rewards + (1 - dones) * self.gamma *  torch.sum(probs_next * (q_value_min - self.log_alpha.exp() * log_probs_next), dim=1, keepdim=True) # 计算t+1时刻的q值\n",
    "        \n",
    "        q_value_1 = self.critic_1(states).gather(1, actions.long()) #计算t时刻的q值\n",
    "        q_value_2 = self.critic_2(states).gather(1, actions.long())\n",
    "\n",
    "        loss_critic_1 = nn.MSELoss()(q_value_1, q_value_target) #计算q网络的损失函数\n",
    "        loss_critic_2 = nn.MSELoss()(q_value_2, q_value_target)\n",
    "\n",
    "        self.opt_critic_1.zero_grad()\n",
    "        loss_critic_1.backward()\n",
    "        self.opt_critic_1.step()\n",
    "\n",
    "        self.opt_critic_2.zero_grad()\n",
    "        loss_critic_2.backward()\n",
    "        self.opt_critic_2.step()\n",
    "\n",
    "        probs_new, log_probs_new = self.actor(states) #计算t时刻的动作\n",
    "        q_value_new = torch.min(self.critic_1(states), self.critic_2(states)) #计算t时刻的q值\n",
    "        loss_actor = (probs_new * (self.log_alpha.exp() * log_probs_new - q_value_new)).sum(dim=1).mean()\n",
    "        self.opt_actor.zero_grad()\n",
    "        loss_actor.backward()\n",
    "        self.opt_actor.step()\n",
    "        \n",
    "        entropy = -torch.sum(probs_new * log_probs_new, dim=1, keepdim=True)\n",
    "        loss_alpha = -(self.log_alpha * (entropy + self.target_entropy).detach()).mean()\n",
    "        self.opt_alpha.zero_grad()\n",
    "        loss_alpha.backward()\n",
    "        self.opt_alpha.step()\n",
    "        self.log_alpha.data = self.log_alpha.data.clamp(-20, 2) # 限制温度参数的范围\n",
    "        ## 软更新目标值网络参数\n",
    "        for target_param, param in zip(self.critic_1_target.parameters(), self.critic_1.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - self.soft_update_tau) + param.data * self.soft_update_tau\n",
    "            )\n",
    "        for target_param, param in zip(self.critic_2_target.parameters(), self.critic_2.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - self.soft_update_tau) + param.data * self.soft_update_tau\n",
    "            )\n",
    "        self.update_cnt += 1\n",
    "        return {'loss_critic_1': loss_critic_1.item(),\n",
    "                'loss_critic_2': loss_critic_2.item(),\n",
    "                'loss_actor': loss_actor.item(),\n",
    "                'loss_alpha': loss_alpha.item()}\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14e02ee1",
   "metadata": {},
   "source": [
    "### 定义可视化函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "81469728",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_curve(cfg: Config, frames: list, rewards : list, label:str = \"rewards\", title:str = None):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    if title is None:\n",
    "        title = f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\"\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(title)\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label=f\"{label}\")\n",
    "    plt.plot(frames, smooth(rewards), label=f\"{label}_smoothed\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg: Config):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    allow_types = ['int', 'float', 'str', 'bool', 'list', 'dict']\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        if v.__class__.__name__ not in allow_types:\n",
    "            continue\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7b4c87a",
   "metadata": {},
   "source": [
    "### 定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "92504308",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "    \n",
    "class EnvMgr:\n",
    "    def __init__(self, cfg: Config):\n",
    "        self.env = gym.make(cfg.env_id) # 创建环境\n",
    "        self.eval_env = gym.make(cfg.env_id)\n",
    "        print(f\"env id: {cfg.env_id}, state_dim: {self.state_dim}, action_dim: {self.action_dim}\")\n",
    "    @property\n",
    "    def action_dim(self):\n",
    "        return self.env.action_space.n # 动作空间的维度\n",
    "    @property\n",
    "    def state_dim(self):\n",
    "        return self.env.observation_space.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2581771",
   "metadata": {},
   "source": [
    "## 2.模型训练与测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "0a3e3413",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def eval_policy(cfg: Config, policy: Policy, env):\n",
    "    ''' 测试\n",
    "    '''\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []  # 记录所有回合的步数\n",
    "    for _ in range(cfg.online_eval_episode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, _ = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            action = policy.predict_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , _ = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            ep_step += 1\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        steps.append(ep_step)\n",
    "    \n",
    "    return {'reward': np.mean(rewards), 'step': np.mean(steps)}\n",
    "\n",
    "def train(cfg: Config, policy: Policy, env_mgr: EnvMgr):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    env = env_mgr.env\n",
    "    eval_env = env_mgr.eval_env\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    eval_rewards = []  # 记录所有回合的奖励\n",
    "    best_policy_params = None  # 最佳策略\n",
    "    best_ep_reward = float('-inf') # 最佳回合的奖励\n",
    "    tot_step = 0\n",
    "    policy_summary_dict = {} # 记录策略更新的参数，如损失等\n",
    "    for i_ep in range(cfg.max_epsiode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, _ = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            ep_step += 1\n",
    "            tot_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , _ = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, terminated or truncated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            # 更新智能体，这里也可以改成每采样50步再更新50次\n",
    "            policy_summary = policy.update()  \n",
    "            if policy_summary is not None:\n",
    "                for k, v in policy_summary.items():\n",
    "                    if k not in policy_summary_dict:\n",
    "                        policy_summary_dict[k] = []\n",
    "                    policy_summary_dict[k].append(v)\n",
    "                if policy.update_cnt > 0 and policy.update_cnt % cfg.online_eval_freq == 0:\n",
    "                    eval_res = eval_policy(cfg, policy, eval_env)\n",
    "                    eval_rewards.append(eval_res['reward'])\n",
    "                    if eval_res['reward'] >= best_ep_reward:\n",
    "                        print(f\"找到新的最优策略，回合：{i_ep+1}，模型步数：{policy.update_cnt}，测试奖励：{eval_res['reward']:.2f}, 测试回合长度：{eval_res['step']}\")\n",
    "                        best_ep_reward = eval_res['reward']\n",
    "                        best_policy_params = policy.get_policy_params()\n",
    "            # policy.update() \n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.max_epsiode}，奖励：{ep_reward:.2f}，回合长度：{ep_step}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'eval_rewards':eval_rewards, 'policy_summary_dict':policy_summary_dict,'best_policy_params':best_policy_params}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b4294aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env id: CartPole-v1, state_dim: 4, action_dim: 2\n",
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t        SAC         \t   <class 'str'>    \n",
      "       env_id       \t    CartPole-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         0          \t   <class 'int'>    \n",
      "    max_epsiode     \t        100         \t   <class 'int'>    \n",
      "      max_step      \t        200         \t   <class 'int'>    \n",
      "online_eval_episode \t         10         \t   <class 'int'>    \n",
      "  online_eval_freq  \t        2000        \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "    lambda_mean     \t       0.001        \t  <class 'float'>   \n",
      "     lambda_std     \t       0.001        \t  <class 'float'>   \n",
      "      lambda_z      \t        0.0         \t  <class 'float'>   \n",
      "  soft_update_tau   \t        0.01        \t  <class 'float'>   \n",
      "     lr_critic      \t       0.0003       \t  <class 'float'>   \n",
      "      lr_actor      \t       0.0003       \t  <class 'float'>   \n",
      "      lr_alpha      \t       0.0003       \t  <class 'float'>   \n",
      "    buffer_size     \t        8000        \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "     batch_size     \t        128         \t   <class 'int'>    \n",
      "       device       \t        mps         \t   <class 'str'>    \n",
      "================================================================================\n",
      "回合：10/100，奖励：12.00，回合长度：12\n",
      "回合：20/100，奖励：12.00，回合长度：12\n",
      "回合：30/100，奖励：26.00，回合长度：26\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 获取参数\n",
    "cfg = Config() \n",
    "env_mgr = EnvMgr(cfg) # 创建环境\n",
    "policy = Policy(cfg, env_mgr.state_dim, env_mgr.action_dim) # 创建策略\n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg, policy, env_mgr) # 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd90699a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAHJCAYAAACrCBICAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAADB50lEQVR4nOzdd3hU1dbA4d/U9B5IAiH0hBoIJVSlSFMRC7Yr+HnFrlz02r1gufarqKhgQRRUsIAgolgQK72DVCGUQEJIAull+vn+mMwkQwopM6nrfR4fyTlnztlzMmVl77XXVimKoiCEEEII0QipG7oBQgghhBCVkUBFCCGEEI2WBCpCCCGEaLQkUBFCCCFEoyWBihBCCCEaLQlUhBBCCNFoSaAihBBCiEZLAhUhhBBCNFoSqLQgUttPCNEYyGeRqAkJVFqIX375hccee8wt51qxYgVxcXGkpKR49DEt0ZYtW4iLi2PLli0N3ZRm5e+//+aqq66iV69eXHbZZZUel5qaysyZMxkxYgS9evVi8ODB3H333WzdurXSxyxdupS4uDjuvvvuKtuQl5fH3LlzueKKK0hISGDIkCHccsst/Prrrxds/5kzZ5gyZQq9e/dmyJAhFBcXX/AxtXH8+HGeeeYZxowZQ3x8PCNHjuTBBx/k0KFDbrvG+Z9FKSkpxMXFufzXrVs3EhISuOaaa/jqq69qfI24uDjefvttt7W5un799Vfi4uLq/brNnbahGyDqx6JFi9x2rpEjR/Lll1/SunVrjz5GCHeZN28ep0+fZt68eYSGhlZ4TGZmJjfccAMRERE8+OCDREVFkZWVxbJly7jlllt48803GTduXLnHLV++nNjYWP7880/S0tKIiooqd8zRo0e54447sNls/N///R/dunWjqKiIb7/9lnvuuYf777+fe++9t9L2f/zxx+zevZtXX32ViIgIfHx8an8zKrFmzRoeffRRunbtyj333EN0dDRnzpzh448/5vrrr+fdd99l2LBhdb5OZZ9F99xzDyNHjgTsPS6FhYUsW7aMmTNnYrFYuPHGG+t8bU/asmULDz30UEM3o1mSQEXUWGhoaKUf9u58jBDukp2dTWxsLCNGjKj0mKVLl5KXl8ePP/6Iv7+/c/vYsWO57rrrKgxUjh49yu7du1mwYAH//ve/+fLLL3nggQdcjjGbzTzwwAPodDo+++wzwsLCnPvGjBnDk08+yZtvvsno0aPp1q1bhW3LycmhdevWVfYG1cXJkyd57LHHuOiii5gzZw4ajca5b9y4cfzjH//gscce49dff0Wv13ukDTExMfTt29dl29ChQzl06BCLFi1qtIFKQUEBH3zwAR988AEBAQEUFRU1dJOaHRn6aQFuvvlmtm7dytatW53DCo4hhi+++IJRo0bRr18/NmzYAMCyZcu45ppr6Nu3L/Hx8Vx55ZX88MMPzvOdP4zz+OOP889//pPly5czfvx4evXqxZVXXsmff/5Zp8cA7Nq1iylTptC3b19GjhzJxx9/zD//+U8ef/zxSp/v22+/zdixY5k7dy6JiYkMHz6c3Nxc53O7/PLL6dWrFyNHjuTtt9/GarUC8NJLL5GYmIjNZnOe6z//+Q9xcXGcPHnSuW3RokX069cPk8lU7fvVo0cPli1bxrBhw0hMTCQpKQmAL774gvHjxxMfH8/UqVM5ffq0y3Ox2Wy88cYbjB49ml69ejF69Ghee+01zGZzlb/zvXv3cttttzFo0CD69evH3XffzZEjR5z7Hb//TZs2MW3aNPr06cOwYcN49dVXnfejIitWrKB3795s376dyZMn07t3b8aPH8+vv/7KsWPHuOWWW+jTpw9jx45l9erVLo+Li4tjz549XH311cTHx3PFFVfw448/upz/u+++Y9KkScTHxzN48GAefvhh0tPTq3yuGRkZPPHEE4wYMYL4+HiuvfZafvnlF+f+uLg4tm7dyrZt24iLi2PFihUVnufs2bOoVKpyz1+j0fDQQw9xww03lHvM8uXLCQoKYvDgwYwfP56vvvoKi8Xicswff/zB4cOHuf/++12CFIcZM2YwderUco9zGD16NCtWrOD06dMuQxoXet6O5z537lyuueYa4uPjmTt3boXX+PTTTzGZTMyaNcslSAHw8fHhscceY/Lkyc73kdVqZf78+UycOJH4+Hj69u3LjTfeyObNm52Pq+h9OGnSpHKfRVVRq9V0797d5X2Rn5/PSy+9xJgxY+jduzcTJ0684PBQTk4OTz31FEOHDqV3795cf/31bNq0qcrH7Ny5k7i4OH777TeX7QcPHiQuLo6ff/4ZgK+++oqlS5fy1FNPMXXq1CrPKWpJEc3ekSNHlKuuukq56qqrlF27din5+fnK5s2bldjYWGXYsGHKDz/8oHz99ddKYWGhsnjxYqVbt27KvHnzlM2bNys//fSTcu211yo9evRQ0tLSFEVRlOXLlyuxsbHKqVOnFEVRlMcee0zp37+/cumllyrfffed8vvvvytXX321Eh8fr+Tk5NT6MUlJSUp8fLxy0003Kb/88ovy1VdfKUOHDlV69eqlPPbYY5U+37feekvp0aOHcu211yrr169XvvvuO0VRFOW9995T4uLilOeee05Zt26dMn/+fKV3797KE088oSiKomzcuFGJjY1V9uzZ4zzXqFGjlNjYWOWrr75ybps2bZoyffp0RVGUGt2vCRMmKL/99puyYsUKxWazKZ9++qkSGxurvPDCC8q6deuUV155RenZs6cSGxurbN682dnmgQMHKl999ZWyZcsWZf78+Ur37t2VN998s9Lnv2nTJqVnz57KtGnTlLVr1yqrV69WJk2apPTr109JSkpSFEVx/v6HDh2qzJ07V9m4caPy4osvKrGxscrnn39e6bmXL1+udOvWTbn44ouVpUuXKuvWrVOuvPJKJSEhQRk7dqzy0UcfKRs3blRuuukmpWfPnuXuwaBBg5S3335b+eOPP5R//etfSlxcnPL7778riqIo27dvV7p37668/fbbyubNm5WVK1cqw4YNU6ZMmVJpezIzM5WLLrpIGTNmjPL1118rv//+uzJjxgwlLi5O+eabbxRFUZRdu3a5vP7PnTtX4bl+//13JTY2Vhk3bpyyYMECZf/+/YrFYqn02mazWRk2bJjy3//+V1EURdm2bZsSGxur/PTTTy7HPfnkk0r37t2VgoKCSs9Vlf379yt33HGHMmzYMGXXrl1KWlpatZ63oihKbGys0rNnT+Wjjz5SfvvtN+Xw4cMVXmP8+PHKtddeW+02vfzyy0qfPn2UTz75RNmyZYuyatUqZfz48UpiYqJSVFSkKErF78OKPotOnTqlxMbGKsuXL6/wWpMmTVIuv/xyRVEUpbi4WJk4caIyZMgQ5fPPP1f+/PNP5amnnlJiY2OVd9991+V5v/XWW4qiKIrBYFAmTZqkDB06VFm6dKny+++/K//617+UHj16KBs3bqzyeY4ZM0Z56KGHXLa98sorSmJiomI0GhVFUZTk5GSX5xwbG1vt+yiqRwKVFmLq1KnK1KlTnT87vqjmzZvnctxLL72kvPrqqy7b9u3bp8TGxjq/8CsKOmJjY5Xk5GTnY7Zu3arExsYqP/74Y60f88gjjyjDhg1zfggoiqLs3LlTiY2NvWCgEhsbq2zbts25LS8vT4mPj1eeeuopl2OXLl2qxMbGKocPH1aMRqOSkJCgvPfee4qi2D+AYmNjlauvvtp5veLiYqV3797OD9Wa3K+VK1c6j7HZbMqQIUOUBx54wOWxjg9dR6Aybdo05dZbb3U55tNPP3U51/muvfZa5bLLLnP5ks3NzVUSExOVGTNmKIpS+vt/4403XB47evRo5a677qr03I7n8tlnnzm3rV69WomNjVXmzJnj3LZ3714lNjZW+fnnn10eN3fuXJd7cOWVVyrXXXedoiiK8v777ysJCQnOLwBFsQcPb7/9tmKz2SpsjyO4S0lJcdl+yy23KMOGDVOsVquiKOVf/5VZvHix0q9fPyU2NlaJjY1V+vXrp9x3333K+vXryx37yy+/KLGxscrevXud28aNG1fu93XHHXcoQ4cOveC1q/LYY48po0aNcv5c3ecdGxur3HLLLRc8f58+fcq9Fqvy4IMPKosWLXLZ9tNPPymxsbHKrl27FEWp+H2oKOV/F45AZdmyZYrZbFbMZrNiNBqVkydPKi+88ILL623JkiVKbGyssnPnTpdz/uc//1F69+6tZGdnO5+3I1D58ssvldjYWGX37t3O4202mzJlyhTlmmuuqfJ5vvXWW0rfvn2V4uJi5+NGjhxZ7nOk7PESqLifDP20cN27d3f5+fHHH+fhhx8mLy+P3bt3880337BkyRIA51BHRUJDQ4mJiXH+HBkZCVDl7IQLPWbz5s1cfPHFLomDCQkJtG3btsbPbdeuXRgMBkaPHo3FYnH+N3r0aAA2bNiAXq9n2LBhbNy4EYBNmzbRsWNHxo0b55z1sWXLFsxmszPXoSb3q2x7jh07xrlz5xg1apTLMZdeeqnLz4MGDWLDhg3cdNNNLFiwgKSkJKZOncqVV15Z4XMuKipi7969XHrppS5d+IGBgYwaNarc7JWEhASXnyMjI6s1xl72cY7hjD59+ji3BQcHA/aZLmVdffXVzn+rVCrGjh3LX3/9hcFgYODAgRQXFzNx4kRee+01tm/fzvDhw5k+fToqlarCdmzdurXC18SkSZPIzMzk2LFjF3wuZU2ZMoX169czd+5cpkyZQlRUFD///DPTpk3j5Zdfdjl2+fLldOzYkZiYGPLy8sjLy2PChAls3LjRZahQo9FUOZxWGzV53ue/xytS0za+9tpr3HLLLWRlZbF9+3aWL1/OqlWrgKpf91WZOXMmPXv2pGfPnvTu3ZsxY8awYsUK7rnnHuew29atW2nbtm251+2kSZMwGo3s2bOn3Hk3bdpEq1at6Nmzp/N9b7VaGTVqFPv27SM3NxebzebyueC4F5MmTaKoqMg5/LNz505Onz5d6ftPeIYk07Zwvr6+Lj+fPHmSp556ik2bNqHT6ejUqZMzwU+povbB+bMQHF8sZfM9avqYrKysCsf0w8PDKz1nWX5+fs5/5+TkAHDnnXdWeGxGRgYAI0aM4Nlnn8VoNLJp0yYSExNJTEzkjTfe4PTp06xbt474+Hhnu2pyv8rea8dYf0hIiMsxrVq1cvn59ttvx8/Pj+XLlzN79mxeffVVunbtyqxZsxg8eHC555Gfn4+iKBXeo/DwcPLz8122eXt7u/ysVqurVeOibLKpQ3Vmopw/6yssLAxFUcjLyyMhIYH58+ezaNEiFi5cyPz58wkPD+fuu+/m5ptvrvB8ubm5tGvXrtx2x/M/P1CqDh8fH8aOHcvYsWMBSE5O5j//+Q8LFy7kmmuuITY2lnPnzvHHH39gNpsZOHBguXN8+eWXPPLIIwC0bduW33//ncLCQpfXZFlnzpxxBurVUZPnff57vCJt2rQplx9VltlsJjc313n+vXv38t///pe9e/fi4+NDly5daNOmDVD+dV/Zcz7f9OnTnbN+1Go1AQEBREdHo1aX/j2dm5tb7j0CVf++c3JyyMzMpGfPnhVeNzMzk5deeomvv/7aua1t27b8+uuvtG/fnoSEBFavXs2ll17K6tWriYmJoV+/ftV6TsI9JFARTjabjTvvvBOdTsdXX31F9+7d0Wq1JCUl8c0339R7eyIjIzl79my57efOnaNTp041OldgYCAAs2fPpkOHDuX2Oz7oRowYgclkYvv27WzZsoVZs2bRu3dvfH192bp1K3/++aezV6Au98sRoJw7d85luyOgclCr1UyZMoUpU6Y4vxzfe+89/vWvfzl7gcoKCAhApVJVeN8yMzOdPR0NJScnxyWIOnv2LBqNxtmuiy66iIsuuoji4mI2b97MJ598wvPPP0+fPn2Ij48vd76goCAyMzPLbXdsOz8QrIzVamXs2LFcddVVzJgxw2Vf+/btmTVrFldddRVJSUnExsayatUqLBYL8+bNIyAgwOX4t99+mxUrVnD//fej1+sZPnw4n376KevWrWPChAnlrp2VlcUll1zCTTfdxMyZM6vVXnc9b4fhw4fz8ccfk5mZWWEg8Mcff3Dfffcxd+5chgwZwu23305cXByrV6+mU6dOqNVq/vjjD3766acaXbestm3b0rt37yqPCQoKIjk5udz2qp53QEAAHTp0YPbs2RWeMzo6munTpzNlyhTntrLvq0mTJvHSSy+Rn5/Pjz/+yD/+8Y9qPR/hPjL000KU/aukMtnZ2Rw/fpxrr72W3r17o9Xa41jHTJyqekc8YeDAgaxbtw6j0ejcduDAgVoVjevTpw86nY709HR69+7t/E+r1fL66687z9mqVSt69OjBZ599RlZWFomJieh0Ovr378/SpUtJTk52DtfU5X516NCBqKiocrNezp9hcOONN/L8888D9t6Ha665hilTppCXl0dBQUG58/r6+tKrVy9++OEHl678/Px8fv/9d/r371/TW+dWa9eudf5bURTWrFlD//790ev1/O9//2Py5MkoioKPjw+jRo1yFgar7K/9gQMHsmvXLlJTU122r1q1ilatWtG+fftqtUuj0dC6dWuWL19OdnZ2uf3Hjx8HIDY2FrDPYurbty9jxoxh0KBBLv9df/31ZGVlOWeFDB8+nNjYWN54440Kz/3aa69hsVi44oorqtVWdz5vhylTpqDT6XjhhRfKDQEVFRXx1ltvERISwsUXX8yxY8fIycnh//7v/+jSpYvzs6W6nxPV+SyqzMCBA0lNTWXXrl0u21etWoVOp6swmE1MTCQtLY2wsDCX9/6GDRtYsGABGo2G6Ohol31li7ZddtllKIrCm2++yblz55g0aVKt2y9qR3pUWojAwEB27drFpk2b6NGjR4XHhIWF0bZtW5YsWUJkZCSBgYGsW7eOTz75BKg638QT7r77br7//ntuv/12pk2bRl5eHm+++SZqtbrSnIXKhISEcPvtt/Pmm29SUFDAoEGDSE9P580330SlUrnUrxg5ciTz5s2jY8eOzr8uBw0axOzZs2nTpo3z2LrcL5VKxcMPP8xDDz3ErFmzmDBhArt37+bzzz93OW7gwIF89NFHhIeHk5CQQHp6OgsXLiQxMbHSujQPPfQQt912G3feeSc33XQTZrOZ+fPnYzKZuO+++2p039ztlVdewWg00rFjR5YtW8bRo0f5+OOPARg8eDALFy7k8ccfZ9KkSZjNZhYsWEBwcHCFw1wAt956K6tWreKf//wn06dPJzg4mJUrV7J582ZefPHFGn0pzpo1i5tvvplrrrmG//u//6N79+7YbDa2bdvmrOPRpUsX/vrrLw4fPsyTTz5Z4XnGjh2Ln58fX3zxBZdffjlarZZXXnmFadOmMXnyZGfBt6ysLFasWMG6det46KGHKvySrYw7nzfYexWeeeYZZs6cyZQpU7jxxhuJiori5MmTLFy4kFOnTvHhhx/i5eVFx44d8ff357333kOr1aLVavnpp5+cU4Qv9DlRnc+iylxzzTV89tln3HfffcyYMYPo6Gh+/fVXli9fzvTp0509p+c/ZvHixdx6663cfffdREVFsXHjRj744AOmTp2KTqer8prBwcGMGDGCzz77jISEhBoHgaLupEelhXD8xXTHHXeUq1VS1jvvvENERASPP/44DzzwAHv27OHdd9+lU6dObN++vR5bbO9y//DDDzEajcyYMYM33niDO+64g1atWlV73LusBx54gMcff5yff/6ZO+64g1dffZX+/fuzePFil+57xzh5YmKic9ugQYMAyhUMq8v9mjhxIm+88Qa7d+/mnnvu4bfffuPZZ591Oeb+++/n7rvvZvny5dx+++28/PLLDB8+nLfeeqvS8w4ZMoSFCxdiMBh48MEHefLJJ4mIiGDp0qXOHoGG8swzz7B06VKmT59OZmYmH330EQMGDADs93b27NkcOXKE6dOn8+CDD+Lj48Mnn3xS6ZBVq1at+Pzzz+nZsyfPP/88999/P2lpabzzzjtMnjy5Rm3r1asXK1euZMiQISxevJg777yT++67j/Xr1/Of//yHZ555BrAn0Wo0mgqHccCe4zJ+/Hi2bt3K0aNHAXtC6VdffcXo0aP5/PPPufvuu3n++eexWq0sWLCg0typyrjzeTtcffXVLF68mIiICObMmcPtt9/Ou+++S48ePVi5cqXz/RAQEMA777yDoijcf//9PProo5w+fZrFixfj5+d3wdd9dT+LKuLj48Onn37KqFGjePPNN7nnnnvYsWMHL7zwAv/6178qfIyvry9Lliyhf//+vPrqq9xxxx2sWbOGhx56iCeeeKJa173yyiuxWq016vUS7qNSqpM5J0QDcCSoOr7IwJ4sN3ToUB599FH+7//+rwFbJ2pixYoVPPHEE/zyyy9ER0c3dHOEEE2IDP2IRmv//v289dZbPPjgg/Ts2ZOcnBwWLlxIQEAAEydObOjmCSGEqAcSqIhGa9q0aZhMJj7//HPS0tLw9fUlMTGRl156SdYNEkKIFkKGfoQQQgjRaEkyrRBCCCEaLQlUhBBCCNFoSaAihBBCiEZLAhUhhBBCNFrNYtaPoijYbO7PCVarVR45ryhP7nX9kvtdf+Re1x+51/XHHfdarVZVq8p4swhUbDaFrKxCt55Tq1UTEuJHXl4RFkv9rnHT0si9rl9yv+uP3Ov6I/e6/rjrXoeG+qHRXDhQkaEfIYQQQjRaEqgIIYQQotGSQEUIIYQQjZYEKkIIIYRotJpFMm112GcG2bDZrNU63mZTYTBoMJmMWK2SRe5Jcq9rR6PRolbL3xpCiOat2QcqiqJQXFxAQUFutYMUh7Nn1dhskj1eH+Re146Pjz+BgaHVmuInhBBNUbMPVPLysiguLsDb2w9vb1/Uak21P9Q1GpX8hV9P5F7XjKIomExGCgqyAQgKCmvgFgkhhGc060DFZrNSXFyIv38w/v5BNX68VquW+fj1RO51zen1XgAUFGQTEBAiw0BCiGapWX+yWa1WQMHLy7uhmyKERziCFavV0sAtEUIIz2jWgUopGb8XzZPkpgghmrsWEqgIIYQQoimSQEUIIYQQjZYEKsLtpk+/kxdeeKahmyGEEKIZkEBFCCGEEJzJKuLbjSc4mZ7f0E1x0aynJwshhBCiasdO5/HDlmR2/p2JAuz4O4Nnbk1s6GY5tdhARVEUTOaq63ZYbYpHanvodeoaz9YYPnwAt956B99//y0Wi5m5cz8gMjKKDz54lzVrfqCwsICOHTtz++13k5g4mKNHk7jllhv58MPFxMV1A+CJJx5m585tfP/9r2g0Gmw2G5MmjeNf/3qQ8eMv49tvV/LVV19w6tQp1GoVsbHdmDHjQbp16wHAtddewciRl7B58ways7N4/vlX6NmzN++99zZr1vyI2Wziyisnoyiuhds+++xTVq78iszMDMLDW3H55ZO45ZbbZMZKI3E8LY/cQhN9u4Q3dFOEEPXoZHo+X/xyhEMnc87bXkBuoYkgP33DNOw8LTJQURSFlxbvJCk1t0Gu3yU6iCem9KvxF/XXXy9j9uy3sFistGsXwzPPzCQ5+ThPPfUcrVq1ZsOGP3n00Qd48cXZDB06nKioNmzbtpm4uG5YrVZ27dpOUVERhw8fonv3nhw4sJ/8/HyGDBnOH3/8xhtvvMJjj82iT58Ezp49y5w5r/Lyy8+zaNFnzjasWLGU//3vDQICAujUqQtz5rzKhg3rmDnzaSIiovjkk4/Ys2cXbdq0BWD9+j/59NOFPPvsi7Rr14H9+//i+eefJiqqDePHX+bW+ypqZ97Xe8nOMzL7vmGEBHg1dHOEEPVAURTmrtjL2VwDGrWKwT0imDAohvnfHuBURgEHT2QxuGdkQzcTaKGBCtAkS6uMH3+Zs3cjJeUUa9f+xMKFS+jaNQ6AG2+cSlLSET777BOGDh3OsGEXsW3bFqZO/ScHD+5Hq9XRq1dvdu7cTvfuPdm0aT19+iQQGBhIUFAQjz/+JOPGXQpAZGQUEydO4vXXX3Fpw+DBwxg4cBAARUWF/PDDdzz00GMMGTIcgCeeeIqdO7c7jz99OgW9XkdkZBsiIyOJjIwkPLw1ERGN4w0gIL/IjALkFZokUBGihTh9tpCzuQZ0WjUv3jGYsCB7YdSeHUI5lVHAfglUGpZKpeKJKf0uOPTjqbLutRn6AYiOjnH++/DhvwG4997bXY6xWCz4+wcAMGzYRaxa9TVGo4Ft27bQv/8AIiPbsGPHdqZMuYVNm9YzYcJEAPr27ceJE8dZtGgBycknSEk5ydGjSeUWCoyObuf898mTyZjNZrp16+nc5uXlRWxsnPPnceMuY/XqVfzjH9fQoUMnBg4cxMiRlxAZ2TjeAC2dopQObxYbpbqtEC3F/hP2dcJi2wU7gxSAHh1D+HHrSQ6cyEZRlEYxRN8iAxWwByteek2Vx2i1ajTqhv8lOXh5lf61qyj2L5d58z7A19fP5TjHmi8JCQPQ6XTs2rWT7du3Mn78ZURFRbFixVLOnEnjyJHDvPDCCADWrPmRF154mnHjLqVXr3iuvPIajh07yuuv/6/SNji6pRxtcdBqS19WwcHBLFz4Gfv2/cW2bVvYsmUTy5Z9zm233cWtt95Rtxsi6sxqU3BkFBWbJFARoqU4cCILsPeglBUbHYxWoyY730jauSLahPtV9PB6JdOTm6iOHTsDcO7cWaKj2zn/W716Fd9//y1gDxgSE4ewfv0fHDiwj/79BxIf3xer1cqHH75Pp05diIpqA8CSJYu44oqrmDnzGSZPvp6+ffuRmpoCUC451iEmpj16vRd//bXHuc1isXDkyGHnz2vW/MDXX39FfHxfbrvtLubPt1/nl1/WeOS+iJqxWEuDTIPR2oAtEULUF4vVxt8lCbQ9OoS47NPrNHSNti/iu78kmGloEqg0UZ06dWbo0It49dWXWL/+T1JTU1iy5GMWL15E27bRzuOGD7+Y77//lvDwVrRtG42Xlze9esXz00/fc9FFI5zHtW4dwd69e/j770Okpqbw5ZdLWLFiKQAmk6nCNvj6+nLttdfz0Ufv88cfv5KcfILZs1/i7NlM5zEmk5F5897kxx9Xk5Z2mj17drNr10569Yr30J0RNWGxlgahBulREaJFOJqai9FsJdBXR3Rr/3L7e3a097IcON44ApUWO/TTHDz77EvMnz+PV199kfz8PNq0iebxx5/k0ksnOo8ZMmQYVquVfv0GOLcNGJDIzp3bGT68NFD5978f5ZVXXmD69DvR63V06RLLrFn/5emn/8OhQwfo0yehwjbcddd09HovXn/9fxQVFTF69FiGDbvYuX/ixKvIzc1l0aIFZGSkExAQwMiRl3DPPTM8cEdETZnL5GAVm6RHRYiWwNFT0qNDKOoKclB6dgjlK45y6FQOFqsNraZh+zRUSmX9+k2I1WojK6uw3Haz2cS5c2mEhUWh09V8PrinkmlFeXKva6c2r3GtVk1IiB/Z2YWcOVvIo+9tAuDyIe2ZPKKzJ5vb4pS91/L69iy519X33MfbOZ6Wx7TLujM8Pqrcfpui8MBb6ykoNvP4lH7Etgt22e+uex0a6oemGkGQDP0I0YKZJUdFiBal0GDmxJk8oHSI53xqlcqZu7K/EQz/1ClQef/997n55ptdtmVkZPDggw8yYMAABg0axEMPPURWlusTXbJkCZdccgnx8fHcdNNNHDhwoC7NEELUUtkcFZn1I0Tzd/BENooCUWG+VdZN6lEyG+hAI0iorXWgsmTJEubMmeOyzWQyMW3aNE6fPs0nn3zC/PnzOXToEI899pjzmK+//ppXXnmF+++/nxUrVhAdHc2tt95aLpgRQniey6wfyVERzZjJbOX1pbtZue5YQzelQVU2Lfl8jv3H0vIoMpg93q6q1DhQSU9P5+6772b27Nl06NDBZd93331Hamoqc+fOpUePHvTp04fHH3+c48ePU1BQAMB7773H1KlTmTRpEl26dOHFF1/Ex8eHZcuWueUJCSGqzyWZVgq+iWbs8Kkc9h3LYvWm5BY9w82ZSFvJsI9DWJA3EaG+KAocTM6ph5ZVrsazfvbv349Op2PVqlXMmzeP1NRU577169czePBgwsNLFze76KKLWLt2LQDnzp3jxIkTDBkypLQBWi0DBgxg27Zt3HXXXbV/ItryMZfNVvtibY5EaJUKmn66ceMm97ruNBpVhe+Bio9Vu/zfwWi2Vvsconoqu9fC/S50r89kFwH2IodJqXn07dryFuHMyC4iM8e+tk/PjqEXfL/37hRKelYRB09mM6hnhHN7fb+uaxyojB49mtGjR1e47/jx4wwYMIB58+axcuVKLBYLw4cP55FHHiEwMJAzZ84AEBXlmmXcunVrDh06VIvm26nVKkJCylfPMxg0nD2rrtGH+PnkA6b+yL2uOZtNhVqtJijIF29v7ws/oIzAQB+8fEpnChnNtgrfR6LuAgN9GroJLUZl9zoz1+j8d9LpPEYltq+vJjUamw/Za1x16xBKm8igCx4/qHcb1m5P4WBydoWfDfX1unZrHZWCggJWrlzJkCFDeO2118jNzeWll17i3nvv5dNPP6W4uBgAvd51GqWXlxdGo7GiU1aLzaaQl1dUbrvJZMRms2G1KjWeQqVS2b84rVab/JXvYXKva89qVbDZbOTmFlFcXL0cE41GTWCgD3l5xeTklr5vCotNZGeXn+Yvaq/svbZaZcqsJ13oXh8/nev8946D6Vw7olN9Nq9R2LYvDYC4dkHVeq+3C/NFrVKRdraQw8fP0irYHpi463UdGOhTrT9Q3RqoaLVafH19ee2119DpdAAEBQVx3XXXsXfvXudffOdXOjUajfj41C0yqygQsVpr/63n+MKUL07Pk3tdd7UJxq1WG8YyCbTFJqvUn/AQq9Um97aeVHSvFUUhNbP0izn1bCGZ2cUtarVwm01xJtJ2jwmp1utRr1UTFxPMweRssnINhPi73q/6el27ta89MjKSjh07OoMUgK5duwKQkpLiHPLJyMhweVxGRgYREREIIepX2WRao8mKzSbRomh+cgpMFBstqFUqolvZS8Y3hmm37nIu18B3G09wLtdQ6TEnzuRTaLDg46WlQ1RAtc995xU9eOjGvnRqE+iOptaKWwOVgQMHcujQIQyG0pt1+LB9gbr27dsTFhZGx44d2bJli3O/xWJh+/btDBw40J1NEUJUg/W8wESmKIvm6PRZe29K6xAf+nQJAxrPgnt1lZJZwPOfbmfFn8d4/tPtpGQWlDvmXK6BBd/Z65X16BCCRl39r/4gfy96dghFVUGp/fri1kDlxhtvRKPR8NBDD3HkyBF27NjBrFmzGDRoED179gRg2rRpLFy4kK+//pqkpCT+85//YDAYuPbaa93ZFNGApk+/kxdeeKahm+FRFouFL79c4vz5ww/f59prr3D7dTx1Xgfzed22LXnapmi+UksClbbhfmUKmWVXujJ8Q9p95CwpGeWDjYocTc3lf0t2kltgQqWC3AIT/1uyk6Oppfk4aecKeXHxDs5kFREa6MW1I5veMhluDVRCQ0NZsmQJFouF6667jnvuuYfevXszd+5c5zHXX389M2bMYM6cOUyePJnU1FQWLlxIaGjVc7qFaEx+/vlH3n77jYZuRp1ZzkuEk1oqojly9KhEhfvRpW0Qep2avEITKZmNK3n8wIks3lr+Fy8t2cHZnOIqj91/PIvZX+ym0GChc9tAXrpzMJ3bBFJosDD7i93sP57FiTN5vLR4J9n5RqLCfPnP1P5EhPjW07Nxnzol07788svltnXo0IH333+/ysfddttt3HbbbXW5tBANqjH+JVYb5wcqMvQjmqPTZXpUdFo1se2C2Xcsi/3Hs2jX2r+BW1dq7fYUAIqNVuZ/d4DHbkqocJhm+6EM3l+1H6tNoWfHUKZf3RsvvYaHb0xg7td72X88iznL9qDVqjGarLSPDODf1/ch0Lfmi/M2Bi22cIWiKChmY8P8V4svueHDB/Dhh+8zefJErrxyPKdOncRsNvPOO29x1VWXMnbsRdx55z/ZunUzAEePJjF8+AD+/ru0Ps0TTzzM+PEjsFrtX0Y2m42JE8fw00/fA/Dttyu55ZYbGT16GGPGDOfee2/n0KHSdZiuvfYK5s6dw9Sp13H55Zewa9cOTCYTb731GhMnjmX8+BG8885b5Z7fZ599yvXXX8moUUO47rpJLFq0oEb3YNOmDdx2281ccskwJk4cywsvPENenn1RrZ07tzNixCD++OM3/vGPaxg9ehgzZtxNevoZ5sx5lQkTRjJx4lg+/vhDl3P+8MN33HLLPxg9ehjXXnsFixYtcN4XgPT0Mzz77JNMmjSeMWOG8+CD00lKOgLA999/y4sv/tf5e9m5c7vzcYsXL+Lqqy9j9Ohh/Otfd3Hq1EnnvoKCAv73vxeYOHEM48ePYMaMu13uL8A336zghhuuYvToYTz22L/Jz8+r9n2qjfOHfmS9H9HcKIriDFTahNtrgTjKwx9Ibjx5KhnZRexJOguAl15DUkou321MLnfcn3tO8+43+7DaFAZ0a82MyfF46TXOx82YHM+Abq2x2hSMJivdYoJ59B8JTTZIATdPT24qFEWhaNUL2NKTGuT6moiu+Ez6T42Tk77+ehmzZ7+FxWKlXbsYnnlmJsnJx3nqqedo1ao1Gzb8yaOPPsCLL85m6NDhREW1Ydu2zcTFdcNqtbJr13aKioo4fPgQ3bv35MCB/eTn5zNkyHD++OM33njjFR57bBZ9+iRw9uxZ5sx5lZdffp5Fiz5ztmHFiqX8739vEBAQQKdOXZgz51U2bFjHzJlPExERxSeffMSePbto06YtAOvX/8mnny7k2WdfpF27Duzf/xfPP/80UVFtGD/+sgs+55ycHGbOfITp0//N0KHDychI57nnnuadd97k8cefBMBqtfLJJx/x9NPPY7FYeOSRB/jnP29i4sQrmT//Y9as+YEPPniX4cNH0LlzF5Yu/Yz33pvL9On/ZuDAQRw4sI/XX/8fubm53H//QxQVFXLPPbfRpk1bXn75NXQ6PR99NJ/p0+9g0aLPueSSsRQUFPDWW6/xzTc/EhgYxK5dOzhzJo29e/fw6qtvYjabeO65p3j55eeYN+8DFEXhkUdmoNd787//zcHf358ff1zNPffcxvvvLyQ2ths///wjr7/+P+6//2EGDEjkzz9/Y/78d2jd2nMz4iznTeGXFZRFc5NbaKLIaEGlgshQ+7CHI1A5fDIHs8WGzg0VmdOzi2gV5INaXbuk0192pKIAvTqFMrRnJPO/PcCqDcfp0SGErtHBAPywOZllvx8F4OI+bfi/8XHlrqfTqrl7Uk++a+VHsdHCNRd3QqfV1Pp5KTYbYEOlbrhwoUUGKgAqGi6DubbGj7+Mbt16AJCScoq1a39i4cIldO0aB8CNN04lKekIn332CUOHDmfYsIvYtm0LU6f+k4MH96PV6ujVqzc7d26ne/eebNq0nj59EggMDCQoKIjHH3+SceMuBSAyMoqJEyfx+uuvuLRh8OBhDBw4CICiokJ++OE7HnroMYYMGQ7AE0885dLDcPp0Cnq9jsjINkRGRhIZGUl4eGsiIiKr9ZwzM9MxmUxEREQSGRlFZGQU//vf6y69HwC3336389707z+QAwf2ce+9M1CpVNx88z9ZtGgBx44l0alTZxYv/phrrrmea665DoB27WLIzc3lnXfe5Lbb7uLnn38kNzeHDz9cTEiIfanzZ555nuuvv4oVK5Zy77334+9v7y4OCystw63Vannqqefw87Pvu/LKa5g//x0AduzYxr59e1m9ei2BgfaKkHfddR979+5h2bIvmDnzGb766kvGjBnnbNfUqf9k//69HDlyuFr3qjYkR0U0d6nOGT++zoCkbSs/gvz05BaaSErNpXv7kDpdY/uhDN5ZuY+L+7Thn5d2q/Hji40W1u89DcDYAe3o3SmMvcey2LT/DPNXHeC/0wayenMyP2y299BeNrg9k0d0qvSPXbVaxaRhHWv1XGyF2VjTk7BlHseacQzr2ROg2PC79nnUga1rdc66apGBikqlwmfSf8BiqvI4rVbtmWI2Wn2tpnpFR8c4/3348N8A3Hvv7S7HWCwW/P3tc+SHDbuIVau+xmg0sG3bFvr3H0BkZBt27NjOlCm3sGnTeiZMmAhA3779OHHiOIsWLSA5+QQpKSc5ejQJm831+UdHt3P+++TJZMxmM9269XRu8/LyIjY2zvnzuHGXsXr1Kv7xj2vo0KETAwcOYuTIS4iMrF6g0rVrHGPGjOexx/5NWFg4AwcOYujQi7j44pGVtsvHx4eoqDbOe+zlZS80aDabycnJJivrHPHxfV0en5DQD4vFQnLyCY4eTaJdu/bOIMVxjh49enL06NFK2xoaGuYMUgACAgKdFZcPHz6EoihMnjzR5TEmk8l5zLFjSYwZM95lf69e8fUbqEiOimhmyuanOKhUKnp0CGHT/nQOnMhyCVQc7wltDZb0+G2Xfc27dXtOM7pfW2IiKq5TYrZYK+zd2LjvDMVGKxGhvvQsWSxw6rhYklJzyMwx8OSHW8nOt39OXDeqM5cOcn/5f8VsxLh9BeZ9a8pV31T5BoP0qNQ/lUoFuqqrEqq0alSqxlNN0surtL2KYm/XvHkf4OvrugaDuiT5KiFhADqdjl27drJ9+1bGj7+MqKgoVqxYypkzaRw5cpgXXhgBwJo1P/LCC08zbtyl9OoVz5VXXsOxY0d5/fX/VdoGSnqlHG1x0GpLX1bBwcEsXPgZ+/b9xbZtW9iyZRPLln3Obbfdxa233lGt5/3MMy8wbdodbN68kW3btvDcc08SH9+XN998t8JrApUGgpXlxjgKndnPU9kxNrRVdKGqq6hNYLPZ8PPz48MPF5fbV1ogUVXlvfSE8sm00qMimpfS/BTX2S49OoSyaX86+49nMXlEZ7LyDKzZdoo/dp+mdYgPT94yoFrBSlaegUPJ2YD9k2P5H8f49/V9yh138EQWb63YS+c2gdx7VW98ve3vbZuisHaHPYl2TP9o1CWfXT5eWu6c1JOXPrXP2lGp4JYJ3bi4T5ta34vKWFIPYPhzIUq+fS0gdVg7NK07o2nVCXXrjqiD26BS1374qK5abDJtU9exo30u/LlzZ4mObuf8b/XqVXz//beA/UsuMXEI69f/wYED++jffyDx8X2xWq18+OH7dOrUhago+4t+yZJFXHHFVcyc+QyTJ19P3779SE21v3kq+3KPiWmPXu/FX3/tcW6zWCwuPQBr1vzA119/RXx8X2677S7mz7df55df1lTree7fv4+33nqNmJgOXH/9Tbz66ps88cRT7NixjezsmifChYaGERoaxl9/7XbZvmfPLnQ6HW3bRtO5c1dOnUp2Ob/RaOTQoYN06GBfH6SmPWKdOnWhsLAQs9ns8vtasuRj1q//A4CuXWNd7iXAoUMHa/wca8Jssf9uHc9GclREc+MMVMJc/6Bz1FNJPpPP/G/389h7m1iz7RRGs5VTGQXsPJxZrfNvOZiOAkSF+aJRq9h77BwHSwIXh/wiE/O/O4DRZOXAiWxe+XwneYX2Hv39x7NIzyrCx0vD0F6uPc2d2wQxdVwsEaG+3HNlL7cHKYqxkOLfP6R49Sso+Zmo/ELxmfBv/CY/h/dF/0TX7WI0oe0aNEgBCVSarE6dOjN06EW8+upLrF//J6mpKSxZ8jGLFy+ibdto53HDh1/M999/S3h4K9q2jcbLy5teveL56afvueiiEc7jWreOYO/ePfz99yFSU1P48sslrFixFCi/NpODr68v1157PR999D5//PErycknmD37Jc6eLX2Dm0xG5s17kx9/XE1a2mn27NnNrl076dUrvlrP08/PjxUrlvHOO2+RknKKY8eS+OWXNURHxxAUFFyLOwf/+MfNrFixlK+//oqUlFOsWfMjH300n0mTrsbf35+xYycQFBTMk08+zsGD+0lKOsKzz86iuLiYK6+8BsC5NtWhQwcxGisvW+0waNAQunaN5emnn2Dnzu2kpJzi7bdf5/vvv3UGP1On/pM///yNzz77hFOnTvLVV1/w+++/1Oo5VpejR8XPx96rI7N+RHNS0Ywfh5AAL9qG+6EAm/enY7UpdIsJJrG7PQ/DMVX4QjbtSwdg7MB2jOhrDyS++j3J+Qeeoigs/P4QuQUmIkJ8CPDVcTK9gJeW7ORcrsF5nYvi2+DjVb4HdWRCW166czADurk3P8RyYheFS/+D5fA6AHQ9LsHvuhfQxpTvDWpoLXbopzl49tmXmD9/Hq+++iL5+Xm0aRPN448/yaWXluZBDBkyDKvVSr9+A5zbBgxIZOfO7QwfXhqo/Pvfj/LKKy8wffqd6PU6unSJZdas//L00//h0KED9OmTUGEb7rprOnq9F6+//j+KiooYPXosw4Zd7Nw/ceJV5ObmsmjRAjIy0gkICGDkyEu4554Z1XqOHTp05IUXXmXhwg/4+utlqNVq+vUbyGuvvVXlUEtV/vGPqej1Or788jPefHM2rVtHMGXKLdx0080A+Pv78/bb7zN37hzuv/9eAOLj+/Duux86ZzP16zeQHj16cc8903jyyecueE2NRsMbb7zDO++8yVNPPU5xcTEdOnTihRdepX9/+/IRQ4cO5+mnn+ejj+azYMF79OzZmxtvnMrPP/9Yq+dZHY5AJcBXR0GxWZJpRbOSV2ii0GCf8RMVVr7Q2ciEtnzxyxH6dg3n0kHt6dQmkJwCIzv+ziQpNZfjaXl0jKp8jZtTGQWkZBag1agY2K01CV1bsWHvGY6n5bPj70wGdGvN77tS2Z10Fq1GxT1X9UKv0/DaF7tIzyri+U+326vKAqP7tfXgnSilGAowbFyCJWkTAOqgSLxGTEMbGVsv168NldIMKldZrTaysspXGDSbTZw7l0ZYWBQ6Xc3nkHssmVaUI/e6dmrzGtdq1YSE+JGdXcirn+1i77FzxEYHcTgll/jOYTxwXeP7i6qpKnuv5fXtWRXd64Mnsnj1i91EhPjw0l1Dqn2u+d/uZ/P+dIb2iuT2iT0qPW7Zb0n8sOUk/WJbMf2a3gCsXHeMVRtOEBHiwz1X9eKFT3dgtti48ZKujBtoT/rPyjPw2pe7STtXBEDfLuHMuLZ6vcy1pSgKluRdGNd9jFKcCyoVut4T8BpwNSptzb4f3fW6Dg31Q1ONPCAZ+hGiBSvtUbF/UBmkR0U0I6mVDPtcyNgB9oBi68F0cgsrHvq2KQqbD9iHfYb0LK11ND4xhgBfHenZxby8ZCdmi41enUIZM6B0SD400JvHp/SjY1QAKhVMGBRT7vzuoCgK1szjGLcspfDLxzCseQulOBd1cBS+k2biPfiGGgcpDUGGfkSDefTRf7Nr1/Yqj/nww8XExLh/Kp6wM5cEKv6+jhwVSaYVzcfpkh6LmgYqHaMC6dwmkKOn8/hjVyqThpevSfL3yRyy8434emmJ7xzm3O7jpWXSsI4s+fkwBpOVQF8dt13ewzmbxyHAV89/bu5PXqGZkICqZ6DWhGIsxJL2N9bUA1iSd6EUnCvdqdGh7zUWff+rmkSA4iCBimgwjz5qXzkbQKNRYbWWH4WMjIyq72a1KI5u2wBHoCI9KqIZOZ1pX4W4poEKwCUDojm66gC/7UrlsiHty01V3rT/DAADurUuVxtlRN82/LIjhfSsIqZd3p0gv4qDAo1a7ZYgxZp1CkvSFiyp+7GdPeFaB0WrRxvTF23HAWhj4lHpvOt8vfomgYpoMOHhrZz/lhyVhuEooR/gUzL0Iz0qoplQFMU59NO2FoHKgLjWfOmfRG6BiW2HMhjSs3TqsMlsZcffGYDrsI+DVqPm8an9yC8y1+ra1aGYijEf3YL50J/YMo+57FMFRaJt2wNN255o2/VCpXVfj01DaCGBSpPPFxaiQnXNhbecP/QjPSqimcgvMttn/FC6xk9NaDVqRie05et1x1m7PcUlUNlz9BzFRithgV50bRdc4eMDffVuXwhQsVmwph7AfHQblmNbwWKvVotKg7ZDAtr2CWjadEftH+rW6za0Zh2oaDQaQIXRaEB3gSq0QjRFJpP9g0qjqd1buez0ZACrTXHbIm1C1BeborB2+yliooLo0sZevt7Rm9Iq2Ae9rnYFy0b0bcu3G09wPC2PRT8cwrtkleIDJ+zFIAf3jCyXe+JuitWMNfUg5mPbsCTvBGPpDFdVUCT6biPQxg5D7VP5NOqmrlkHKmq1Bh8fPwoKcrBYzHh7+6JWa6pdVdRmqzhvQrif3OuaURQFk8lIQUE2Pj7+ta4p40ym9dE5txWbLOiaUKKdEBv3nuGTH+3rn0WF+TIhMYaikt7B2uSnOAT66RnUI4INe8/w557T5fYP7lm9NctqQlFs2M6dwpq6H0vqAaxph8FaOvNI5RNozzfpPAhNZGyt1o1rapp1oAIQGBiKTudFQUEOBkP5WitVUavV5RblE54h97p2fHz8CQysfTevIy9Ip9XgpddgNFkxGC1u77IWLU9BsZlDydn0i22FWu3ZL1NHYqtKBWnnilj4wyHnvroEKgDXj+pCqyAfjBbX/K32EQFuzT9RjIWYDvyGef9alKIcl30qnyC0Hfuj7TQQTWQcqlr+YdJUNftARaVS4evrj4+PHzabDZutesmCGo2KoCBfcnOL5C99D5N7XTsajbbWPSkOjmRanUaFd0mgUizr/Qg3WLnuGL/uTPXYar8OZRcFfPPBkWzYncKPW06SW2DvhYhuXbdgIsBXX+H0ZHex5WVg2rsG89/rSnNOtF5o2nRzJsSqQ9q2iJ6TyjT7QMVBpVKh0WhK8lYuTKtV4+3tTXGxVWajeJjc64ZTdkl7H72WXEyygrJwi+T0fADW/5XGhMSYWn/RWqw2jqbm0jEqsMJcE8eigLHtgunYJohgHy2jE6LZfOAMWXlGBrp5jZy6UswGrOlJWNP+tv+XfsQ5nVgd1g597wloOyei0ugucKaWo8UEKkIIVzZFwWqzf0BqtWp8vOxfAlL0TbhDelYxYB+KOZleQPvIgBo9vtho4Y/dp1mz7SQ5BSaXMvVlbd5vrw5bduVhnVbNRfHuXWm4LhRDAeakzZiPbsaWcQwU1z/INO16o+89AU3bHi2656QyEqgI0UI5elMAtGo13nr7x4GU0Rd1VWQwU1Bsdv68af+ZagcqeYUmft5+il93prpMl995OJPDp3KILTMdOCWjgFMZ9kUBE3uUr2fSkBSbBeupvZj/Xo/l5G4ok3agCghHExmHJioWbZvuqAMbV69PYyOBihAtlMVSmg+k06qcS8xLj4qoq/TsYpeftxxI57pRndFcIKcqr8jEfxdtIzvfnqsRGerLpYNiOJKay/q/0vjq96M8MbWfs9dh0wF7Em1853CXmWsNwTlb5/QBLKkHsZ45DGaDc786vD262OFo2yegDghvwJY2PRKoCNFCle1R0WjUzhoR0qMi6io9y77GTuc2gaRnF5NbaOJgcja9OoZV+hhFUVj0/SGy8420CvbmhtFd6ds1HLVKRe/OYWw9mE5Sai67j5wlIbaVfVHA/eUXBaxvirEQ07619tk6hnyXfSqfQLRdhqCLHY4mrF0DtbDpk0BFiBbKEaho1CrUKhU+ekePigQqom4ySnpUosL9iIkM4LedqWzal15loPLbrlR2J51Fq1Ez/Zp42rX2d+4L9vdi3MB2fLcxma/+OEp8lzCOnMqtcFHA+qIYCzHtXYNp3xowlfQg6bzRRMaWzNbpgTo0GpWqZU0l9gQJVIRoocwlM6y0JVVovb0cPSoy9CPqJj3b3qMSEeJDXEwIv+1MZefhTIwmK1768jN3UjIL+PLXJACuG9XZJUhxmJDYnt93nSbtXBEb9p7haGouUPGigJ5iK87DeuYw1tMHMR/eCGZ7gKIOaYM+YRLaTgNQqeVr1d3kjgrRQjl6VHQlq8KW5qhIj4oolZVn4LUvdxPs78WEQTH06hh6wZkpjhyViBBfOrcJpFWwN5k5BnYdySxXzdVktvL+qv2YLTZ6dwpjTP/oCs/p661l4tAOfPHLEVauO4bRbH/9enLYRzEU2KvDph7AeuZvbDlpLvvVIdHo+09C23GA9Jx4kAQqQrRQjvL5Go39S8dHLz0qorwNe9NIO1dE2rkiDiZnE93Kn0sHx5DYvXWlybGOHJWIUF9UKhVDekayasMJNu1PLxeoLPv9KKmZhQT66ph2efcqg6BRCW35edspzuXZk1SrWhSwtqwZR7Ec34EldT+2syc5f1FbdUi0fbZOu95oYvpIgFIPJFARooVyzPpx9Kh4S46KqMCuI2cB6BYTzPG0fFIyC/jg2wOs2nCCJ6b2K7fcQkGxfdVigNbBPoB9TZxVG06w/3gWuYUmgvz05BWaWLPtFL/sSAHgtok9CPKreukGnVbN1Rd3ZMF3B53nddeigLacNIxblmJJ3uWyXR0SjaZtD7RtuqOJ7IrKu/ywlPAsCVSEaKHKVqWF0hwVKaEvHLLzjZw4k48KuOvKXmg1Kn7dmcqarSdJzypiy/50xg50nc3iSKQN9tc781EiQ33pGBXA8bR8ftp6EqPJyvq9ac48qfGJ7ejdqXoJsYN7RPLbzlROZRQwrHdUnZ+jrTgP045vMB/8zV6ITaVG2ynR3mMS3RO1b3CdryHqRgIVIVqo8wMVx6wfKaEvHHYfyQSgc9sgZ2/HFUM7gKLw9brjHD2dy1hcA5XSRFpfl+2De0ZyPC2fH7ecdG7rGBXApYPa0z+uVbXbpFarePgfCRhNVgIv0ANTFcViwrRvLaZd3zqTYjUxffEadD2akMZT1VbUMVB5//33Wb9+PZ9++mmF+2fNmsXGjRv59ddfndtsNhtz585l2bJl5OfnM3DgQJ566inatZM55kLUJ0eOik5bkqPi5QhUpEdF2DmGfRK6uhYo69Q2CIBjp/PKPaY0P8XHZfug7hF8/ecxDCYrvTqFcumg9nSLCa5VyXgvnQavCtb9qQ5FUbAc34ZxyzKUfHsgpg5vj9fgG9G26V6rcwrPqnWgsmTJEubMmcOAAQMq3L927VqWLVtG27ZtXba/8847fPbZZ7z88stERkby6quvcvvtt/Ptt9+i18vS8kLUF8cCkJpyQz/SoyLsr4ODJasS9z0vUOkYGYgKOJtrIK/I5JKnklFmxk9ZgX56npmWiM2mEBnquq++WDOPY9z0ub1qLKDyDcYr8Vq0XYdKUmwjVuPfTHp6OnfffTezZ8+mQ4cOFR6TkZHBk08+SWJiost2k8nERx99xIwZMxg5ciTdunXjjTfe4MyZM6xZs6ZWT0AIUTtma8XJtAaTFZuiVPo40TLsO56F1aYQEepLVJifyz5fby2RYfZg4/xeFcfQT+sQ1x4VsCfXNlSQYj62jaKVz9mDFI0efb8r8bvhf+hih0uQ0sjV+Lezf/9+dDodq1atok+fPuX2K4rC448/zpVXXlkuUDl06BCFhYUMGTLEuS0wMJAePXqwbdu2WjRfCFFbjh6V0hyV0q50owz/tHi7SvJTzh/2cejUJhAoH6hU1qPSkCwnd2P45T1QbGg79MfvhpfxGnA1Kp1XQzdNVEONh35Gjx7N6NGjK92/aNEiMjMzee+993j//fdd9p05Y19AKirKNVO7devWzn215aiu6S6O7nDH/4XnyL2uX4777Og10evUaLVqNBoVGrUKq03BbLUR4Ob3VEvUVF/bFquNv46eA+yVXyv6fO0aHcyGvWc4kZbn3J9fZHJOTY5q5ef2z+WqVHavzaf2UfzzPFCs6LoMxm/M3agusDiiqFp9v67dOuvn0KFDzJ07lyVLllSYb1JcbI+0z9/n5eVFbm5ura+rVqsICfG78IG1EBhYvvtSeIbc6/qlKUlG9PXRO98/vt5a8ovM6L31HntPtURN7bW950gmRQYLQf56BvRqg0ZdPuE1oXski344xLG0PIKCfFGrVaTn2Vc9Dg/yJrJ1YH03G3C918UnD5Dz45tgNeMbm0jENf9GpZHJru5SX69rt/3GjEYjDz/8MPfccw/dunWr8Bhvb2/Anqvi+LfjsT4+tX/CNptCXl5RrR9fEY1GTWCgD3l5xVjLrDIr3E/udf1y3O+CAvuXis1qIzu7ELDPpsjHTHpmPv56+auzrprqa/vPnacAiO8cRl5uxZ+tgd5q9Do1RQYLB45m0jbcj6QTWQC0CvZxvqbqy/n32pyyn4If3gSzEW1MPPpRd5GTZwSM9dqu5shdr+vAQJ9q9cq4LVDZs2cPR44cYe7cucybNw8As9mMxWIhISGBDz74wDnkk5GRQUxMjPOxGRkZxMXF1en6jvF2d7NabR47t3Al97p+mcz2PBSNuvT9412Sp1JQZG4Wv4vTZwsJ9tfj661r0HY0pde2oijs/Nuen9K3c3iV7e4QEcDhlFyOnMwhItiH02ftwUmrYJ8Geb6KomBI3kfxtpVY0w4BoInqhveY+7AqGmgiv4Omor5e124LVOLj48vN3Pn0009Zs2YNn376KREREajVavz9/dmyZYszUMnLy+PAgQNMnTrVXU0RQlSDY9aPtsxfNN6OhQmbwRTlUxkFPPPRVnp2CuXB6/s2dHOajJTMQs7mGtBr1fToGFrlsZ3aBHE4JZdjaXkMj48iI6ckkTa0foe6FEXBfPIvTq/6FmPK3/aNag262IvwGnwDKq0kzTZlbgtUvL29ad++vcu2oKAgtFqty/apU6cye/ZsQkNDadu2La+++iqRkZGMGzfOXU0RQlSD9bzKtFC2Om3Tn/Vz9HQuCrD/eBZFBnOD96o0FY7ZPj06hF6wqFrpzB97jqGz2Fs9zvix5aRh2LgEa8o++waNDl23i9H3uQy1f/XK8ovGrd6zimbMmIHFYmHWrFkYDAYGDhzIhx9+iE4nHyJC1KfSyrRlAhVH0bdmUEY/s+Sve0WBg8k5NSrT3lKdzS1m3Z7TQOXTkstyBCopGYUYzVbSnVOTPd+jopiKMe36FtPen8BmBbWWoIGXQrex2LwaJpFXeEadApWXX365yv3/+te/+Ne//uWyTaPR8Mgjj/DII4/U5dJCiDo6v44KlCn61gyGfjJLvjQBDpzIkkDlAlLPFvL6l7vJzjcSHuRN/7jWF3xMSIAXwf56cgpM7DuWRbHRgoqKi725i82Qj+XoFky7vkMpygFAE9MHv4umEtahE9nZhdgkF6VZkXlaQrRQZufQT+nUU0cybXEzGPrJzDE4/72/ZDaKqNjxtDzeWLqHgmIzbcL9eOiGvvh6X/jrQaVS0alNEDsPZ7J5v70WVkigFzpt7dbhqYxiKsZyYifmo5uxpuy3r3IMqAJb4z3kJrTt+6KRuj/NlgQqQrRQFkv5ZFrnwoRNvEdFURRnYifYq6WezSkmPLhp1TOpDwdPZPHWir0YTVY6RgXy7+v74O9T/aH4Tm0C2Xk4kz1H7QsYujM/RbGYMO35HtPu78Fqcm5Xh7dH13UYuu4jUWlljbjmTgIVIVooi62iZFr7X8JNPZm20GBxzlyKifDnZHoB+09kMaJv2ws8smVJPpPPG8v2YLEqdG8fwvRrejuD1erqFGXPB7GUzCJzR36KoihYkndi3PQ5Sr49AFIFRaLrMhhd50Gog6MucAbRnEigIkQL5chRKZtM21ymJzsSaYP89fTtEs7J9AIOnMiWQOU8f+w5jcWq0LNjKDMmx7u8FqqrQ1QAKpU9aRmgdR17VGw5ZzBsWoL11F4AVH6heA25EW3HgahU5SvkiuZPAhUhWqiKclQcf0039RwVR6DSKtiHnh1DWbXhBAeTs7EpCmr5sgPsaz3tLpmKPG5gu1oFKWBPwG4b7kdKpr3YW21rqCgWI6Zd32Ha871zFo8+fgL6hCtk8cAWTgIVIVqoimf9lAz9NPEeFccKvq2DfegYFYi3XkNBsZmT6fl0iJSpq2Af9skpMOGl19AtJqRO5+rUJqg0UKlFj4oleReGjUucwzyadr3xHjoFdVBkndolmgcJVIRooSqqTOso+NbU66iU7VHRatR0iwlhd9JZ9h/PkkClxK4j9qCgd8fQWvemOHRqE8ife06jAloFe1/weAdb7hmMm7/EkrwLKBnmGToFbYd+MswjnCRQEaKFslRQmdbbq3kk0zoCldYls3x6dgxld9JZDpzI5vIhHRqwZY2HY9gnoWvd68t0ax+CVqMiupV/taYm2wrOYdr5Dea/19unGqs06OPHo+93pQzziHIkUBGihXIEKrqyOSqOHhVj8whUWpUEKj062Ic2jqTkYDRbL1gavjnIyjOwZtspLukf7bwPDpk5xaRkFqJWqejdue5l5lsH+/D0rYn4X6D2iq0oF9Pu7zAf+A1s9l47TUwfvAZdjyZEEp1FxSRQEaKFcuaoVFBC32K1YbbY6jwk0BDMFhtZeUYAWpVMlY0M9SU00IusPCNHTuXQq1PzXgPGYrXx9vK9JKfncyItj8emuA6lOIZ9YtsF1ahmSlXahvtVuk8xFmL660dMe9eAxf670UR1w2vgZDSRXd1yfdF8SaAiRAtlrmDox0tf2tNgMFnQNcFiWufyDCiAl05DoK/9S1ilUtGjQyjr/0pj/4msZh+orPjzGMnp+QAcTsnlr6Pn6NOldO0ex7BPXzcM+1RFsRgx7fsF057VYLQn26pbdbIHKG17SB6KqBYJVIRooSwVJNNq1Gr0OjUms41ik5WA+lsE120cM35aBXu7fBH2dAQqx7Mbqmn1Yv+JLH7cchKA2OggDqfk8tUfR+ndKQy1WkVBsZnDp+yrHVdn4cHasiTvxrBukXM9HnVIG/QDJ6NtL4myomYkUBGihSqdnuz6peGj12Iym5rsFOXz81McupfkqaRkFvDz9lPoygRocTHBRIVVPnTRVOQVmVjw3QEARia0ZfKITjz27iZSMwvZtP8Mw3pH8dfRs9gUhehWfuXukbuYDv6Ocf3HoCioAsLx6n812i5DUKmb3lCiaHgSqAjRQpUm07p+eXh7acktNDXZmT+VBSqBvnraRwSQnJ7P52uPuOwLCfDi1XuGolY33b/0FUVh0feHyC0wERXmyw2ju+Cl03D50PYs++0oX687RmL31uwuyU/xxLCPoiiYdqzEtPMbAHRxF+M1/GZUGvfkwYiWSQIVIVooZ47KeQmzjvV+mmoZ/coCFYB/jOnK2h0p2GyKc9v+41lk5xs5djqPLtFBHm1bocFMVp6R6FZ+NRr+SDtXiJ+3jkC/ynOGftuVyu6ks2g1Ku6a1NM5s+mSftGs3Z5CVp6Rn7aeYu9x+0rS7h72UWxWjOs/xnzoTwD0/a5E3/8qGeYRdSaBihAtkNVqc67Noj2/R8URqDTRom+OVZNbV7A4Xmy7YGLbBbtse3/VfrYcSGfXkUyPBirFRgvPf7yd9OxiOkQGcNng9vSLbXXBXpyDydm89sVugvz1/HdaYoWzdFIyC/jy1yQArhvZhZiIAOc+vU7DVRd1ZOH3h/h63TEUBYL99XSIDCh3nppSbDZsOalY049iOboF6+mDoFLhNez/0PcYVefzCwESqAjRIplL8lOgghyVkvV+DE2wloqiKFX2qFQkoWs4Ww6kszvpLNeN6lLhMcVGCyqVfV2b2vrs58OklyT6njiTzzsr99E6xIcJiTEM6x1ZYaG0gmIzC747gE1RyM43suiHQ9x3dS+XXgqT2cr7q/Zjttjo1SmUMQOiy51nWK8o1mw9RepZ+8ybvl1b1amnw3xiJ+b9a7FmHAOzoXSHRof3Jfeg69Cv1ucW4nyS2SREC+QY9oGKelRKApUmmKOSV2jCZLahAsKDqlfKvVfHMDRqFWnnijiTVVRuf7HRwswPNjPzgy3kFppq1a7N+8+wYd8ZVCr41zW9mTSsA37eWjKyi/nkp7954dMd5J13bkVRWPTDIbLzjYQFeqNRq9h5OJM/9px2OW7Z70dJzSwk0FfHbZdXPOVXrVYxeURn58+1HfZRrBYMG5dgWPMW1tQD9iBF542mTXf0CVfge/XTEqQIt5MeFSFaIEePigrQqM/vUWm6OSqZOfa/7kMDvcoFYJXx9dbSLSaY/Sey2XUkk0sHtXfZv35vGjkF9iDiw9UHeOC6PhWuwGwrGUs7f196VhGLvj8EwBVDO5AQ24qE2FZMGBTDuj1pfLvxBCfTC3hpyU4euqEP4UH2nqA/9pxm5+FMNGoV913Ti0PJOSz9LYkv1h4hNjqYNuF+7Ek6yy87UgC4bWIPgqrIYenTJYyL+7Qhr9BE9/Y1X4TQVnCO4rXzsGUcA0DXezy62OGoQ9rKbB7hUfLqEqIFKluV9vy/wB1DP00xR6Wmwz4OjhkwjoqtDjZFcQYCAPuOZfHL9hTOl51v5NmF27j/zXWs+POos3fEarPx2pIdFBktdG4byBXDOjgf463XMnZgO2be3J+wQG/Ss4p4afFOTp8t5PTZQr4omZk0eURnOkQGMi6xHT07hGCy2Hh/1X7O5hbz4eqDAIwd0I7eFyhip1Kp+Oel3ZhxbXy1gzgHy8m/KFz+lD1I0fviM/5+vIf8A01YOwlShMfJK0yIFqiiqrQOjmTappijklHLQMUxFHI0JZe8otIhmL1Hz5GRXYyPl5brRtmHTpb9nsTJkqqvAOnZRby0eAcnMwooNFj4bmMyj7y7kU9++pvPfz7CwRNZ+HhpuPOKnmgq+FKPCPXlian9iArzJTvfyMtLdjLv672YLDZ6dghhXGI7wN5Tc9vEHvj76DiVUcAzH22joNhMu9b+XDuyc7nzuotp708U//g6GAtRh3fA75r/om2f4LHrCXE+CVSEaIHMlRR7g9IclZr2qPy+K5X/zN/sDBYaQmYVM36qEhroTfuIABRgT1Jpr8ra7acAuLhPFBMSY+jbJRyLVeH9Vfsxmq2cTM/npcU7OZtroHWID9Mu606nNoGYLTZ+35XKmm32x//z0u5VBk+hgd48PqUfHaMCKCg2k3auCH8fHbdN7OEylBTs78W0y7sDUGS0oNequXNST4+syaQoNgybv8S46XMAdN1H4nvlTNSBni27L8T5JFARogUyW+y9JRX1qPj52AOVgiJzjc65YW8aZ7KKOHgiq+4NrKXa9qgA9C3pVXEUREs9W8j+E9moVPZaJCqVilsv60aQv560c0W8u3If//tsF3mFJtq19ueJqf0ZHh/FzJv789hNCc6hmPGD2zOkV+QFrx/gq+fhGxPo1TEUvVbN7RO7E+zvVb6dXcIZn9gOFTBlbGyViwHWlmK1YPjtA8x//QCAPvE6vIbfIoXbRIOQZFohWiBHj8r5VWkBQkq+HHMKjDU659k8eyJrUQMm4dY2RwXswz/frD/O/uNZGM1Wfi3JTenbJZzwkvMF+Oq5fWIPXvtiN38dPQdAl+ggHrg2Hl/v0gUQ42JCiIsJwWy1ERURSE5O+dlEFfHx0vLgDX0xmqwuC0Se7/pRXbhiaAfnNd1JMRVTvHYe1pR9oFLjPWIautjhbr+OENUlPSpCtECWSqrSAgQHOAIVE4qilNtfEbPFRm7JzJgiQ8MEKkaz1dmG2gQq7Vr7ExbojcliY/uhDDbsSwNgzIB2Lsf17BDK5UPsM4PiO4fx0A19Kw0YfLy0tapXUlWQAvZgyBNBiuXMYYpWPmsPUrRe+Ex4QIIU0eCkR0WIFqiqHJVgP3ugYjRbMZiszllAVcnOLy361VA9KmdLelN8vbQVVm+9EJVKRd+u4fyyI4XP1h7BZLbRtpUf3WKCyx07eURnLoqPolWwT7MoEa+YijBuWYb54G8AqHwC8Rn/AJrWnRq4ZUJIoCJEi1TV0I+XXoOPl5Zio4WcAmO1ApVzuaWBSnED9ajUJT/FIaEkUHHUkBk7oF2lgUjrEN9aX6cxMR/fgXHDpyhFOUDJQoKDrkfl7d+wDROihAQqQrRAjkBFU0k9jWB/PcVGC9n5RqLCLpyseS6vNJ+loXpUHMXeWgVXryJtRWLbBTuDND9vLYN6RLireY2OLS8Dw8YlWE/uAUAVFIH3Rf9E26Z7A7dMCFcSqAjRApX2qFTcWxAS4EXauaJqJ9SeyyvtUSk01Gy2kLtklqyj06qGU5PL0mrUJHQNZ+O+M4xMaOtcgbg5USwmTHt+wLT7O7CaQaVB3+dS9P0modJWXtlWiIYigYoQLZClioJvgHNarKN0/IWUHfppqGTazNy6D/0A3HhJV7q3D2l2vSmKqRjLyT0Yt69AycsAQNOmO17DbkYT0qaBWydE5eoUqLz//vusX7+eTz/91Lnt119/Zd68eRw7doyQkBDGjx/P/fffj7e3vTvWaDTy8ssv8+OPP2IwGBg9ejQzZ84kNDS0bs9ECFFtZkvls36gNFDJzq95j0pDDP3YFIVTGQUARNQxUPH30TGsd5Q7mtXgbEU5WJJ3YzmxE+vpA2C1/25UvsF4DfkH2k6JzSIZWDRvtQ5UlixZwpw5cxgwYIBz2/bt25k+fTozZsxgwoQJJCcn89RTT5GTk8NLL70EwDPPPMP27dt5++230ev1PP3008yYMYPFixfX/dkIIaqlqmRasA/9QPVrqZQNVDyRTJuRXUSx0Ur7yIAK9x85lUN2vhEfLw1dooPcfv2mxlZwDuP2FViObIQyU8xVga3RdR6Evs9lqPR1C+iEqC81DlTS09N5+umn2bJlCx06dHDZ98UXXzBo0CDuvvtuADp06MC///1vZs2axX//+1+ys7NZuXIl7733njPAef3115kwYQK7du0iIUHWjxCiPjgq02oqyVEJ9rfnKlQnULEpClllAhWTxYbZYnNbWXdFUXj1813kFJh45taBtG1VfjbKpv1nABgQ1xqdtvnllVSXYirCtHs1pr1r7PkngLpVR7Qd+qFt3w91SBvpQRFNTo0Dlf3796PT6Vi1ahXz5s0jNTXVuW/atGmoz1t0S61WYzabKSgoYMeOHQAMHjzYub9jx45ERESwbds2CVSEqCeWC/SoOHNU8i+co5JfaMJiVVCpAAUU7MM/QW5KzMzMNThnFf2yI4X/m9DNZb/ZYmXboUwAhvS8cKn65kgxGzEf+gPTrm9RDPYFEzVRcXgNukFqoYgmr8aByujRoxk9enSF+3r06OHys9lsZtGiRfTq1YvQ0FDS09MJCQnBy8t1/YrWrVtz5syZmjbFRWVj7bXlmLZZ2fRN4T5yr+uXRqN2rp6s12kqfO+EleR55BQYUWtULgvjnS+n0B7MhPh7YTBZKTJaMFmsbntPpmQWOP+9cd8ZbrikK35lCrrtOpJJsdFCaIAXPTqFVtnW+ubp17atKA/jvp8x7l2LYiwEQB0chc+QG9B1SGhRvSfyOVJ/6vtee2zWj8Vi4dFHH+XIkSMsWbIEgOLiYvT68n9leXl5YTTWbF2RstRqFSEh7l+YCyAwUMZx64vc6/rjyFHx9/Oq8L0TUPK7sNoUtHodQRUsjudQnJwDQESYH+fyDBQZLWh0Wre9J9NzXIeVtv6dyTWjujq3bfvb3psyakA7wkIbZ5Eyd762FUXBlH6CvJ1rKNj7O4rFHihqgyMIHnIVAX0vQaVuucNf8jlSf+rrXnskUCkoKOCBBx5g69atzJ07l/j4eAC8vb0xmcp3JRuNRnx8av+EbTaFvLzqLfpVXRqNmsBAH/LyirGW/PUpPEPudf3SaNTOoR+LxUp2dmGFxwX66ckrNHEiJZuYiIqTWAFOns4FIMhPR2Gx/f19JjOf1oGVBzc1cei4fTXmzm0DOZqax6o/j3FxfCQatZqCYjPbDqQD0L9reKXPpaG487Vtzc3AdGQzpiMbsWWfLr1G6054J1yGruMArGo1OWWmirck8jlSf9x1rwMDfarVK+P2QCUjI4M77riD1NRUPvzwQwYOHOjcFxkZSU5ODiaTyaVnJSMjg4iIutUscHzwupvVavPYuYUrudf1xzH0o1ZV/t4JLglUzuYYaFNFdVpHobXQAG9ySqYz5xea3fK7VBSFE2fyALh2RGfmfb2Pc3kGth/MpH9cKzbvO4PVptCutT+Rob6N9vVTl9e2Je1vTNtXYE37u3SjRos2pi+6nmPQRMWhUqmw2gBb43z+9Uk+R+pPfd1rtwYqubm53HLLLRQUFLBkyRLi4uJc9vfv3x+bzcaOHTsYMmQIAMePHyc9Pd0loBFCeNaFpieDfRXlkxkFF5z545iaHBbkTdo5e4+Gu2qpZOcbyS8yo1ap6NQmkBF927B6UzJrt5+if1wr52yf5phEa80+jWnrMizJu+wbVCo0bXqg6zIYbcf+qPTNY60hIS7ErYHKSy+9xKlTp1iwYAGhoaFkZmY694WGhhIREcHll1/OrFmzePHFF/Hx8eHpp58mMTGRvn37urMpQogqlK6eXEWg4pz5U81AJdALX2/7R0qRm8roJ5+xz2BpE+6HTqthVEJbfth8kr9P5bDrcCZHUnJRQbOqImsrzMa08xvMh/4ExQYqNbpuI9D3m4TaL6ShmydEvXNboGK1Wvn+++8xm83ccsst5fb/8ssvREdH89xzz/Hiiy8yffp0AC6++GJmzZrlrmYIIarBWUK/ipk51a2l4iifHxbojZ+3fTaOu3pUktPtgUr7SHuSbGigN/3jWrHtUAYLVh8AoFv7EGeBuqbMmnUK018/YknaDDZ7nRtth37oE69FEywl7kXLVadA5eWXX3b+W6PR8Ndff13wMb6+vjz//PM8//zzdbm0EKIOSntUKp++Ghxw4fV+io0WZ1ASGuiNr5ejR8VNgUpJj0r7Msm8Ywe0Y9uhDIqN9i/zpj7sY0k9gGnP91hT9jm3aaLi0A+4Bm1UXBWPFKJlkEUJhWiBHJVpq8pRCanGej+OYR8/by0+Xlp8vN0cqJT0qHSIDHRu69w2kPaRASSfyUenVdM/rpVbrlXfbPmZGDYswXpyt32DSoW240D08ROkSJsQZUigIkQLVKMclSqGfsoO+wClPSpuGPrJLTCSU2BCBbRrXVofRaVScfng9ryzch+De0Tg49W0PsYUqxnTXz9i2vktWE2g0qDrPhJ9/HjUga0bunlCNDpN6x0uhHCLagUqJUM/eYUmrDYbGnX5Y8vO+AFKc1Tc0KOSnG6vSBsZ5ouX3rWA2YBurXnhjkGEl1y3qbCcPoRh3SKUXPtsJU1UN7yG34wmpG0Dt0yIxksCFSFaoNJk2spzVAJ8dWjUKqw2hbxCc4UJq45AJdTRo+LGWT/JJfVTKlsxOaqK2i6NjWK1YNy6AtPu1YCCyicQr8E3ou0ypEWVuReiNiRQEaIFqk4dFbVKRZC/nqw8I9n5xooDFQ8O/Th6VNpXURW3KTDnpJO/8jWs6UcB0MVdjNfgG1B5NZ1AS4iGJIGKEC1QdYZ+wJ6nkpVnrDRP5fyhH98yybSKotSpt8Ax46dDJT0qTYHpyGZS/lyEYiwCvQ/eF9+KrlNiQzdLiCZFAhUhWqCaBCpQeUJtVp59e9h5Qz9Wm4LJYsNLV7vF8QqKzc4gqF3rpheo2IrzMG5YjOXYVgA0kV3xHnUX6oDwBm6ZEE2PBCpCtEDVqaMCpVOUKwpULFabs2qto0fFS6dBrVJhUxSKDJZaByqOacmtQ3ycwU9ToCgKlqObMW5YgmIsAJWa4GHXQK/LsdokF0WI2mg6nwBCCLexWEsqn1ZRmRYgOMBenbaiWipZ+UYU7L0yAb722T4qlQpfby0FxWaKDBUn4FbHyQoKvTV2tsJsDOsWYT25BwB1aDv8Rt9OaFwv+6rOsmCgELUigYoQLZDZogBVJ9NC2aGf8tVps3JL1/hRl8lF8fUqCVTqkFBbWjq/aQQqllN/Ufzr+2AsBLUGfb9J6PtcjtZLf+EHCyGqJIGKEC2Moiil05PrkKNyfiKtg68bqtM6S+c38kBFUWyYdn6LacdKQEEd3gHvkXegCZW6KEK4iwQqQrQwFqvi/PeFclSc6/1UMPTjmJrsqKHiUNdApchgIT27GGjcQz+KoYDi3+ZjPWVf40zXfSReQ6eg0ugauGVCNC8SqAjRwjh6U+DCPSohJSsoFxosmMxW9GWSYx09KuHnByp1rKVyKsPemxIW6I2/T+P80rdmnqB47VyU/LOg0eF90S3oYoc3dLOEaJYkUBGihXHM+IELJ9P6eGnRa9WYLDZyCk20DvZx7rvw0E/tqtMeO111RdqGpCgK5oO/Ydz4GdgsqAJa4TN2Oprw9g3dNCGaLQlUhGhhHD0qGrXKJQm2IiqViuAALzKyi8nJN7oGKpUN/XiVrPdTix4Vm6Lw519pAPToEFLjx3uSYirGsO5jLEc3A6Btn4D3yNulwqwQHiaBihAtTHUTaR2C/UsClTIJtYqicC7PtYaKQ11yVPYfzyI9qwgfLw1DekbW+PGeYs1KwfDzXGy5Z0ClwWvQdeh6j5d1eoSoBxKoCNHCmEuSaS807OMQXJKnUjahNq/IjMVqQwWEnlcrpS6BytrtKQAM790GH6/G8fFkOXOY4h9eB7MBlV8I3pfcizaya0M3S4gWo3F8Eggh6o2lmlVpHSqqpZKRXQRAkL++XM9MbZNp084VsvfYOVTAJf0bx/TeskGKJqob3mPuRe0T2NDNEqJFkUBFiBbGMfRzoWJvDo7qso6hH6vNxtLfkgDoGFX+S7u2PSq/7kgFoE+XcFqH+NbosZ7gEqS07YnP+BmotLWrtCuEqL3qfVIJIZqN2uSoQGkZ/W83nOBoah4+Xhr+cUn5IRBfb0cybfVn/RQZLKzfZ0+iHTMgutqP8xQJUoRoPKRHRYgWxjE9WVfTHJUCI4dP5fDtxhMA3Dw+jvAys4AcnEM/NehRWb83DaPJSptwP7q3b9jZPpbThyj+aY4EKUI0EhKoCNHCOCrTVrdHxTH0k51v5INv96MoMLRXJIN7VDwrxzn0Y7RgU5QLToG22RR+2XEKgDH9oxt0Jo358AYMf34ENqsEKUI0EhKoCNHCmK01S6YNKhn6MVlsnMsz0irYmyljYys93tGjoihgNFkvOHvnr2PnyMwx4OetbbApyYpiw7T9a0y7vgVA22kg3iPvQKWVRQWFaGgSqAjRwpTO+qlej4qXToOvl5YiowWNWsVdk3pVGXzodRq0GjUWq40ig+WCgcra7fbelIv6tMFLr6nyWE9QLCYMvy/AcmwrAPq+E9EPvAaVSlL4hGgM5J0oRAvjnPVTzRwVgIhQey7KVRd1pFObC0/PdQz/FF6gjP7R07kcOJGNSgWj+9X/lGTFbKRo9Sv2IEWtwXvEbXglXitBihCNiPSoCNHC1HTWD8Ctl3XnVHoBg3pGVOt4Xy8teYUmiquopaIoCst+OwrAsN5RhAeVT8z1JEVRMKxbhC09Cbz88Bk7HW2b7vXaBiHEhUmgIkQL48xRqUGPSnQrf6Jb+Vf7+OrUUtl77ByHT+Wg06q5anjHap/bXcyH/sCStAlUanzGzUAbFVfvbRBCXJj0bwrRwlgsJbN+1J6bXVN25k9FbDaFZb/be1PG9I8ut7Chp1kzT2DcsBgAr8RrJUgRohGTQEWIFqY2OSo1daFaKpv2nyE1sxBfLy2XDWnvsXZURDEWUrx2HtgsaNsnoIu/tF6vL4SoGQlUhGhhzDWc9VMbjuq0FSXTmi1Wvl53DIDLh7bHr+TY+qAoCobfF6DkZ6IKaIX3yNtlBWQhGrk6fVK9//773HzzzS7bDh48yNSpU+nbty+jR4/mk08+cdlvs9l46623uOiii+jbty933HEHp06dqkszhBA1YLHVPEelpqpamPCXHalk5RkJCfDikn71Wy7f/NePWJJ3gVqLz5j7UHn51ev1hRA1V+tPqiVLljBnzhyXbdnZ2dx6663ExMSwfPly7rvvPmbPns3y5cudx7zzzjt89tlnPPfcc3zxxRfYbDZuv/12TCYTQgjPc9RRqe6ihLXhyFEpPm/op8hgZvWmE4B9qrNeV391U6znTmHc9hUAXkNvQtOqQ71dWwhRezWe9ZOens7TTz/Nli1b6NChg8u+pUuXotPpePbZZ9FqtXTu3Jnk5GTmz5/P5MmTMZlMfPTRRzz88MOMHDkSgDfeeIOLLrqINWvWMHHiRHc8JyFEFczOEvr1n0z78/YUCg0W2ob7MaxXlMeufz7Fasbw23ywWe15Kd1H1du1hRB1U+M/qfbv349Op2PVqlX06dPHZd/27dtJTExEqy2NfwYPHsyJEyc4e/Yshw4dorCwkCFDhjj3BwYG0qNHD7Zt21aHpyGEqK6aVqatDcfQT+F5PSp7j50DYFxiO9QenHV0PtP2r7FlnULlHYDXRf+UvBQhmpAa96iMHj2a0aNHV7jvzJkzxMa6rgHSunVrANLS0jhz5gwAUVFR5Y5x7Kstd4+3a0o+xDUe/DAXdnKv65fVZu9R0es0HstTCfC1r5FTbLQ4r2E0WUk+kw9Ar05hHs2RKcuS9jemPT8A4DvyVvSB9bc6s7y264/c6/pT3/farQXfDAYDer3rIl5eXvYFzYxGI8XFxQAVHpObm1vr66rVKkJCPJMUFxhYv9UyWzK51/WkpCcjwN/LY++byNb2nDOD2eq8xp7DmVhtCuFB3nTtEFYvvRo2UzEpvy0AFPzjR9K6/wiPX7Mi8tquP3Kv60993Wu3Bire3t7lkmKNRiMAvr6+eHvbizqZTCbnvx3H+PjU/gnbbAp5eUW1fnxFNBo1gYE+5OUVYy2pOyE8Q+51/SoumTJsMVvJzi70yDWsZvuQT0GRyXmN7QfSAOgaHUxOjnvfr5Up/H0hlpx01P5haAfe6LHnWxl5bdcfudf1x133OjDQp1q9Mm4NVCIjI8nIyHDZ5vg5IiICi8Xi3BYTE+NyTFxc3SpDOsbd3c1qtXns3MKV3Ov6YTbb77FG7bn3jb5kWKfYaMVksqJWq/j7ZA4AXaKD6uX3bEn7G9OB3wDwGnk7Vo03NNDrS17b9Ufudf2pr3vt1gGmgQMHsmPHDqxWq3Pb5s2b6dixI2FhYXTr1g1/f3+2bNni3J+Xl8eBAwcYOHCgO5sihKhEbRYlrClHMi3YZ/5YrDaOptqHd2Ojgzx23bJMO78BQNdthCw2KEQT5tZPqsmTJ1NQUMDMmTNJSkpixYoVLFq0iLvuuguw56ZMnTqV2bNn88svv3Do0CH+/e9/ExkZybhx49zZFCFEJcz1EKhoNWr0Ovv5i4wWks/kY7LY8PPWEhXu+SJrljNHsKYeALUGfb9JHr+eEMJz3Dr0ExYWxoIFC3jhhRe4+uqradWqFY8++ihXX32185gZM2ZgsViYNWsWBoOBgQMH8uGHH6LT1V8ZbSFaMmfBNw/PuvHz1mEyGyk2WDickgNAbLtg1PWQROvsTYkdjto/zOPXE0J4Tp0ClZdffrnctvj4eL788stKH6PRaHjkkUd45JFH6nJpIUQt1cfQD9iHf7LzjRQZzBw5ZR/26Rod7NFrAljTk7Cm7AOVBn1fKSIpRFMnE86FaGFKK9N69u3vU1KdtsBg4UiZHhVPM+5cBYAudijqwFYev54QwrMkUBGihSmtTOvZIRhHQu2RlBwKDRa8dBpiIvw9ek1rxjGsp/4ClRp9whUevZYQon5IoCJEC+MY+vF0jopjvZ89SWcB6Nw20OO9OI7eFG2XIagDW3v0WkKI+iGBihAtTH3M+gHw87InyGfmGACI9XB+ivVsMtaTu0Glwkt6U4RoNiRQEaKFcfao1FOOioMn81MURcG4bTkA2s6DUQdHeuxaQoj6JYGKEC2MxVKSTOvpoZ8yRd80ahWd2gR67FqWw+vtuSlqDfp+0psiRHMigYoQLYjNpmBTHLN+PJxMW6ZHpUNUAHqdxiPXseVlYNi4BAD9gGvQBLfxyHWEEA1DAhUhWhBzmQXEPJ6jUiZQ8dSwj2KzUvzbfDAb0ETGoo+/1CPXEUI0HAlUhGhBLGUCFY/P+ikz9OOpRFrT7tXY0pNA5433qDtQqeUjTYjmRt7VQrQglpJib2DPG/EkX2/7rB8V0NUDCxFaM49j2mEvle897GbUAVLcTYjmyK1r/QghGrey6/yoVCpAqfoBddAm3JeY1v7ERAQ4gxZ3USxGDL++D4oVbaeBaLsOdev5hRCNhwQqQrQg9VXszX4NDc9MS3T7eRVFwbDuY2y5Z1D5BuM9/JaSoEsI0RzJ0I8QLUh9FXvzJPOBX7Ec2QgqFd6j70Ll7dmy/EKIhtV0P62EEDVWnz0qnmBNT8K46TMAvBKvR9umewO3SAjhaU3z00oIUSuOYm9NMVCxFeVS/PNcsFnRdhyALn5CQzdJCFEPmt6nlRCi1ppqj4pis2L45R2UohzUwW3wHnGb5KUI0UI0rU8rIUSdlK7z45kqsZ5i3PoV1rS/7fVSxk1Hpfdp6CYJIeqJBCpCtCDOZFpt0+mNsGYex/zXjwB4j7hNSuQL0cJIoCJEC+Io+KbTNo0eFUWxYVj/KaCg7TIEXaeBDd0kIUQ9k0BFiBbEWfCtiUxPNv+9DlvmMdB54zX4hoZujhCiATSNTyshhFtYnEM/jf+trxgKMG39CgCv/leh9g1u2AYJIRpE4/+0EkK4TVOa9WPcvgLFkI86pC26XmMaujlCiAbS+D+thBBuY7Y2jToq1rPJmA/+BoDXsKmo1LLahxAtVeP+tBJCuJWlCZTQVxQbhg2fgqKg7ZQo1WeFaOEa76eVEMLtyq6e3FiZD/2JLT0JtF54Db6xoZsjhGhgjffTSgjhdkVGCwB+3roGbknFrGeTMW5cDIDXgKtQ+4c2cIuEEA1NAhUhWpDCYjMAAX76Bm5JeYqx0L6Wj9WCJqYPut7jG7pJQohGQAIVIVqQQoO9RyXAt3H1qCiKjeLfPkDJz0QVEI7PqDtRqeTjSQghgYoQLUqBo0fFt3H1qJh2f4/15G7QaPEZOx2Vl19DN0kI0UhIoCJEC1JoaHyBiiX1AKbtywHwGnYzmvAODdsgIUSjIoGKEC2Io0fFv5EM/djyMzH88q59KnLsRejiLm7oJgkhGhm3ByoWi4U333yTUaNGkZCQwJQpU9i9e7dz/8GDB5k6dSp9+/Zl9OjRfPLJJ+5ughCiAoqiUFhsz1EJbATJtIqpiOIf59irz4bF4D38ZlSqprOqsxCifrg9UHn33XdZtmwZzz33HCtXrqRjx47cfvvtZGRkkJ2dza233kpMTAzLly/nvvvuY/bs2SxfvtzdzRBCnMdgsmJT7JVp/Rt46EexWSn+5V1s2amofIPxGf8AKm3DB09CiMbH7XWp165dy8SJExk+fDgAjz/+OMuWLWP37t0cP34cnU7Hs88+i1arpXPnziQnJzN//nwmT57s7qYIIcpwDPvotWq8dBqKGrAtxk2fYT21FzR6fMY/IPVShBCVcnugEhYWxm+//cbUqVOJioriyy+/RK/X061bN5YtW0ZiYiJabellBw8ezPvvv8/Zs2cJDw+v9XXdvRqspqTEuKYRlxpvLuRe1w+D2QqAn489P6Wh7rdh78+Y9/9ib8uYu9BHdWqQdtQHeW3XH7nX9ae+77XbA5WZM2dy//33c8kll6DRaFCr1bz99tvExMRw5swZYmNjXY5v3bo1AGlpabUOVNRqFSEhnpnOGBjo45HzivLkXnvW8YxCAIL8vYCGud9FSTvJXr8EgNBRUwgeMLLe29AQ5LVdf+Re15/6utduD1SSkpIICAhg3rx5REREsGzZMh5++GEWL16MwWBAr3cdh/bysn9oGo3GWl/TZlPIy3NvR7ZGoyYw0Ie8vGKsJQu5Cc+Qe10/0jPzAfDx0gDU+/22pB8l/5tXQbGh73YRtm7jyM4urLfrNwR5bdcfudf1x133OjDQp1q9Mm4NVNLS0njooYdYtGgRAwYMAKB3794kJSXx9ttv4+3tjclkcnmMI0Dx9fWt07Udi625m9Vq89i5hSu5156VV2h/7/l529/29Xm/bTlpFK1+HSwmNNG90A+7BatVAZR6uX5Dk9d2/ZF7XX/q6167dYBpz549mM1mevfu7bK9T58+JCcnExkZSUZGhss+x88RERHubIoQ4jyOZNr6XpDQVphN0fez7dOQwzvgM+Y+VBq3d+YKIZoptwYqkZGRAPz9998u2w8fPkyHDh0YOHAgO3bswGq1Ovdt3ryZjh07EhYW5s6mCCHO46ihUp/F3hRTEcU/vI5ScA5VYAQ+lz6ISi85BEKI6nNroBIfH0///v157LHH2Lx5MydOnGDOnDls2rSJO++8k8mTJ1NQUMDMmTNJSkpixYoVLFq0iLvuusudzRBCVMBZlbaeelQUYyHFP72JLesUKp9AfC97CLVPYL1cWwjRfLi1/1WtVvPuu+8yZ84cnnjiCXJzc4mNjWXRokX06dMHgAULFvDCCy9w9dVX06pVKx599FGuvvpqdzZDCFEBxzo//j6eD1SsZ09Q/PM8lPxM0Hnjc+lDqANbe/y6Qojmx+0DxUFBQTz99NM8/fTTFe6Pj4/nyy+/dPdlhRAX4AhU/DwYqCiKgvnQHxg3LgarBVVAOD5jpqMJb++xawohmjfJaBOihShw5Kh4KFBRLEYM6z7BcmQDAJqYvviMugOVl2dqHAkhWgYJVIRoIQqLPTv0Y1j3MZYjG0GlQj/wOvR9JqBSSZVQIUTdSKAiRAtgUxSPDv3YivOwHN0CgM+Ef6NtF+/2awghWib5c0eIFsBgtFCycDJ+Pu7/+8SStAlsVtStOkqQIoRwKwlUhGgBCgz2/BS9To1eq3Hrue0JtOsA0MVd5NZzCyGEBCpCtACFHqxKa8s8ji07BTQ6dJ0Huf38QoiWTQIVIVoATybSmv+296ZoOw6QGT5CCLeTQEWIFqDAkUjr7d78FMVixJy0GZBhHyGEZ0igIkQL4Fjnx90zfizHd4C5GFVAKzRturn13EIIARKoCNEieGroxzHso4sbLjVThBAeIZ8sQrQABR5IprXlZWA9fRBQoYsd7rbzCiFEWRKoCNECeGJBQkdviia6J2r/MLedVwghypJARYgWoLCkjoq7kmkVmw3zYfuaPrq4i91yTiGEqIgEKkK0AM6hHzf1qFhO7kIpzAIvP7QdEtxyTiGEqIgEKkK0AO5MplUUG6btKwHQdx+FSuOZRQ6FEAIkUBGiRShNpq370I/l+A5sWadA540+fkKdzyeEEFWRQEWIZs6mKBSV5KjUtUdFsdkw7fgaAH3v8ai8/evcPiGEqIoEKkI0c8VGCyULJ+Nbx+nJlmNbsWWfBr0v+t7j6t44IYS4AAlUhGiEzuYWU2y0uOVcjmEfL50Gnbb2b3nFZsW4YyUA+vgJsq6PEKJeSKAiRCOTnlXE4+9t5t1v9rnlfI7y+f4+dctPsSRtRsk9A15+6HuNdUfThBDigiRQEaKRSckswKYo7DuWRXa+sc7nc0dVWsVmwbjzGwD0fS5Dpfepc7uEEKI6JFARopFxBBYAe46erfP5HFVp61JDxXJ4I0peBirvAPQ9L6lzm4QQorokUBGikXFUkQXYfcQNgUodi70pNgvGXasA0Pe9DJXOu85tEkKI6pJARYhGpmyPyoET2RhMdUuqdZzPv5Y1VCxHNqHkn0XlE4iux+g6tUUIIWpKAhUhGpnCMoGKxWpj37Gsup3Psc5PLXpUFJsV465vAdDHX4pK61WntgghRE1JoCJEI3P+AoK76jj848xRqUUyrSVpszM3RXpThBANQQIVIRoZx1DNoB4RAPx19CxWm63O5/Or4fRkxWZz9qbo4ieg0klvihCi/kmgIkQj4+gB6dMlHD9vLYUGC0kpubU/X3Htyudbjm0trZsivSlCiAYigYoQjYyjByTQV0+fLuFA3YZ/CmtRR0Wx2TDtLJnp03u81E0RQjQYCVQ8LDvfyKIfDnIyPb+hmyKaAEVRnD0gfj5aEro6ApVMFEWp6qGVcvTQ1KRHxXJ8O7ackjV9eo2p1XWFEMIdPBKorFy5kssuu4zevXtz+eWX88MPPzj3paSkcNddd9GvXz+GDx/OnDlzsFqtnmhGo7DlQDp/7klj7faUhm6KaAJMFhsWqz0fxc9bR8+OoWg1ajJzDKSeLazx+Wy20pWTqzvrR1HK9qaMQ6X3rfF1hRDCXdweqHzzzTfMnDmTKVOmsHr1aiZOnMiDDz7Irl27MJvN3HbbbQB88cUXPPPMM3z++efMmzfP3c1oNIpKFpYrctMCc6J5cwzTaNQqvPUavPVaenQIAWo3/FNUZuVkv2rWUbGe/AtbdgrofGRNHyFEg6vbKmXnURSFN998k//7v/9jypQpANxzzz1s376drVu3kpqayunTp1m6dClBQUHExsZy7tw5XnnlFe6++270er07m9MomMz23iJjHYt2iZahoEwVWZVKBUDfruH8dfQcu4+c5YqhHWp0Pkfg463XoNVU7+8S8/HtAOjihssKyUKIBufWHpXjx4+TmprKFVdc4bL9ww8/5K677mL79u307NmToKAg577BgwdTUFDAwYMH3dmURsMZqJhrP71UtBzn11AB6FuSUHs8La/GixTWdEFCxWbDenIPANr2CTW6lhBCeIJbe1SOHz8OQFFREbfddhsHDhwgOjqae+65h9GjR3PmzBkiIyNdHtO6dWsA0tLS6NOnT62vrdW6dxRLU/LXp6aaf4VWxlySb2A0W93exubCXfe6OSgu6XkL8NU7Xy/hwT50ahPIsdN5HEnJYWjvqGqfz1ASKAf46pznq+p+W84cRTHkg94Hr+huqOR3Uify2q4/cq/rT33fa7cGKgUFBQA89thjTJ8+nYcffpiffvqJe++9l4ULF2IwGAgMDHR5jJeXvYiU0Vj75ezVahUhIZ7pog4MrNu0TBv27nuz1eaxNjYXdb3XzYGisr/xQwK9XV4v0REBHDudh1mp2WtdUdvL7wcHeJd7XEX3O2v3fgD8OicQGh5Ubr+oHXlt1x+51/Wnvu61WwMVnc7evXzbbbdx9dVXA9C9e3cOHDjAwoUL8fb2xmQyuTzGEaD4+tZ+ZoHNppCXV1Trx1dEo1ETGOhDXl4xVmsdqoIW2p9vkcFCdnbNZ220BO66181Bxjl7sK/XqlxeLzq1PeA9m1VYo9dR+tmS8+nUzsdVdb/zD20DQGnTW16vbiCv7foj97r+uOteBwb6VKtXxq2BSkSEveR3bGysy/YuXbrw+++/k5iYyOHDh132ZWRkuDy2tiwWz7wwrVZbnc7tSKI1mqwea2NzUdd73RzkF9pzSny9tC73wsfL/lbNLzLV6B7llwTKfuedD8rfb1v+WaxZp0ClQt22d4v/XbiTvLbrj9zr+lNf99qtA0w9e/bEz8+PPXv2uGw/fPgwMTExDBw4kAMHDjiHiAA2b96Mn58f3bp1c2dTGg1HEq3RbMVWy4JdouUoqGQBQf+S5FpHsm21z1eDdX4sJ3cDoInoisrbv0bXEUIIT3FroOLt7c3tt9/OvHnz+O677zh58iTvvvsuGzZs4NZbb2XMmDG0atWKBx54gEOHDrF27Vpef/11pk2b1iynJgOYLKXF7BwzgISojGM68flVZB3F2hz7q30+5yyiC8/6sSTvBkAT07dG1xBCCE9y69APwL333ouPjw9vvPEG6enpdO7cmbfffptBgwYBsGDBAv773/9y/fXXExQUxE033cS9997r7mY0GsYywYnRbMO7ecZjwk0Ky9RRKcsRaDjK4df0fBcqn6+YirGePgSAtn3fGl1DCCE8ye2BCsCtt97KrbfeWuG+9u3b89FHH3niso2S0VQmUDFZwE8iFVG5gpIeEP/zqsj61nXo5wI9KpbU/WCzoApsjTq4+tOfhRDC02TCuYeZyiQaGUwy9COqVmmPSq2HfqrXo2JJLinyFtPHWRFXCCEaAwlUPMhmUzCXCVSMkqMiqqAoijOwqCyZtshgqVFSdtmVmCu/rg3rKalGK4RonCRQ8aDzAxMJVERVjGYrFqs9CDm/B8S3JHBRgOJqLnBptlidi2FWNfRjyziGUpwHOh80kbGVHieEEA1BAhUPMp03v9woQz+iCo7eD61GhV7n+tbUadV46TT246qZp7L8j2MABPnrqxz6sTjW9mnXC5XGI2lrQghRaxKoeND5PSiSoyKq4hz2KbNyclnOhNpq5KnsPXaONdtOAXDLhG6o1ZXnnTjqp2hlWrIQohGSQMWDzq+bIkM/oiqOGTr+lQzTVHeKcm6hiQ+/OwDAJf2inasvV0QxG7GdSwFAE92zxm0WQghPk0DFgyRHRdREaXG2iodf/H0cPSqVD/0oisJHqw+SV2SmbSs/rhvVucpr2nJOAwoq7wDUvsG1arcQQniSBCoeZDpvqEdyVERVCiqZmuxQnR6VtTtS2HvsHFqNmrsm9URfktdSGVuWvTdFHRpdmyYLIYTHSaDiQcbzkmklR0VUpbIaKg6OKcaVJdOeyihg2W9JANwwugvRrS68Xo9VAhUhRCMngYoHSY6KqIkLFWdzTFGuLJn2t50pWKwK8Z3DGN2vbbWuactOBUAdUr3jhRCivkmg4kGSoyJqorTcfcU5Kn7OMvoVBypZ+UYA+sW2qnZ1WcfQj0Z6VIQQjZQEKh5kMksdFVF9pVVkKxv60bkcd77cAhMAgdVcT8pmyEcpygGkR0UI0XhJoOJBjh4UTUkNC8lREVUpMFQ9Pdn/Asm0uYX2HpWgagYq1iz7sI/KPwyV3qdGbRVCiPoigYoHOXJUHH/hnp+zIkRZF0ymLbPez/lsikJeof3x1Q5UzkkirRCi8ZNAxYMcPSoBvvYvHoMEKqIKF6qj4kimLaigR6Wg2OxcrLC6Qz9WyU8RQjQBEqh4kCNHxfHFITkqojKKojh7VCqb9eNXpuCbct4Kynkl+Sn+Pjq0muq9rZ01VCQ/RQjRiEmg4kGOHpUgX3ugIjkqojIGkxWrzR58XKjgm8VqK7fgZW6hPVCp7rCPoihlhn7a1arNQghRHyRQ8SDn0I/kqIgLcPSmlF0l+Xzeeo0zMfv8Wip5hTWb8WPNz0IxFYFKjTo4srbNFkIIj5NAxYOcQz8lPSomiw2bTanqIaKFulB+CoBKpao0odbZo+JfvUDFlHkSAHVwJCpNxT04QgjRGEig4kHnJ9OW3SZEWY4E2cqGfRyctVTOS6it6dRkU0YyAOoQSaQVQjRuEqh4kCMo8ffRoVZJLRVROWcibSU1VBx8S3pUCoor6VHx86rW9UyZpwBQh0oirRCicZNAxYMcOSleOg1eerXLNiHKulANFYfKVlB2VKWtcY+KTE0WQjRyEqh4kCMo0es0zgRJ6VERFSkoyTnx96k8RwUqD1ScybTVyFFRbDbMZ0tqqMjQjxCikZNAxYOMJcm0Xjo1XnptyTYJVOrT1oPpfLT6IObzpvM2Ns4elQsM/ThqqVSaTFuNHhVbXjqK1QxaPaqAVrVprhBC1BsJVDzItUfFfqulR6X+WG02Pv3pb9bvTWP/8ayGbk6Vqjv041zvp8z0ZIvV5lx5uTqBiqN+iiakLSq1fAQIIRo3+ZTyEJuiOItyeek0eJcM/UiOSv1JSsl1Tvs9l2do4NZUreACVWkdnMm0ZXpUHMM+GrXqgoEOlCmdHybDPkKIxk8CFQ8xm0uHGuzJtPYvGOlRqT+7jpx1/jsrv3EHKtWpowJlpieX6VHJLVPszTG7rCqyxo8QoimRQMVDyuai6HRqvPSactuFXXa+keW/HnH2KriDoijsLhOoZOcZ3XZuT3Akx16oR8WRw1I2RyW3plVpz0mgIoRoOiRQ8RBnfopWjVqlcuaoSKBS3uqNJ1i0+gC/7Uxx2zlPny0kI6fY+XNWExn6qW4ybdlZP3k1SKRVLCZsuWcAGfoRQjQNEqh4iLFMIi2At06GfiqTnm0PKLLc2OvhGPYJLKkKnJVfs3PvP57FqYwCt7WnKvaVk0uGfqqbTFsmUMktqH5VWltOGigKah9/VL7BtWyxEELUH48GKsePHychIYEVK1Y4tx08eJCpU6fSt29fRo8ezSeffOLJJjSYslOTgdKhHwlUyskuyR/Jd+PQjyNQGdG3bck1jNVeZykrz8DrX+7mra/2uK09VSk2WrEpJSsnXyBHxZFMW2y0YrHaX2M1WefHVpKfom8Vg6oa+SxCCNHQPBaomM1mHn74YYqKipzbsrOzufXWW4mJiWH58uXcd999zJ49m+XLl3uqGQ3GdF6PSmmOiqXSx7RU2SW9HfklX7juON/xtDwARvRtg0oFVpvi/EK/kPTsYhTgXJ7RGQx4kqN3RK9VO18vlfEtE8gUGe2vpZqUz7ec3G2/VkSHWrRUCCHqX9V/vtXB22+/jb+/v8u2pUuXotPpePbZZ9FqtXTu3Jnk5GTmz5/P5MmTPdWUBnH+0I+jMq3R3LgLj9U3s8VKfpH9i9pdybR7kuy9KR2jAgkN9CbY34vsfCNZ+QZCAi78ZZ5TZpgov8hcrcfURWE1FyQE0KjV+HhpKTZaKDJYCPTVV7vYmy0/E8vx7QAE9LmEoiqPFkKIxsEjPSrbtm3jyy+/5OWXX3bZvn37dhITE9FqS+OjwYMHc+LECc6ePXv+aZq0sjVUALxl6KdC2QWlvRx5Re7pUdldEqgkdA0HIDTQHmhUd+ZP2anM+W5qU1Wqm0jr4BgeckxRziuo3qwf096fQVHQRvfCS3pUhBBNhNt7VPLy8nj00UeZNWsWUVFRLvvOnDlDbGysy7bWrVsDkJaWRnh4eK2vq9W6N+bSaNQu/68px5CBt16DVqt2dtkbzVa3t7UpyyszHFNQZEajUdUpd8JgsnDwRDYAA7q3RqtVExbkw9HUPHIKjdW692WHiAoMFo//vhwJ1gG+umpdy99Xx9lcA4aS15KjvWFB3pU+XjEWYf77TwB8+10G1P61Laqvrp8jovrkXtef+r7Xbg9UnnnmGRISErjiiivK7TMYDOj1rn/1eXnZ/9o1Gms/40OtVhES4lfrx1clMNCnVo/TaO09KP5+ekJC/AgLtbfPYlM81tamyHQ82/lvq01B7+N1wVoiVdnw12nMVhtRYX706toalUpFm1b+QDqFRlu17n3Zqq9WPPfacrCp7G/2kCDval0r2N8byEdRq/H29XIOM7aPDsHHq+K3dM7mtWA2oGvVjrBeiUDtX9ui5uRe1x+51/Wnvu61WwOVlStXsn37dr799tsK93t7e2MyuXalOwIUX1/fWl/XZlPIy3PviLtGoyYw0Ie8vGKstUiozM6zT7lVKZCdXYjZaO+mLyo2k51d6Na2NmWnzuS6/JxyOoeI0Nq/FtbtPAVAny5h5OTYXxN+Xvag8XRmfrXuffq50tfSmWo+pi4yztmnQes16mpdS18ykyzjbAHJKfZAz0unwVBkxFBUPuBXrBZyt3wHgK7XOPLzDXV6bYvqq+vniKg+udf1x133OjDQp1q9Mm4NVJYvX865c+cYOXKky/ann36a77//nsjISDIyMlz2OX6OiIio07UtHlod12q11ercxSV/leu0aiwWGzqNY1FCi8fa2hSdy3UtxJaTbyQs0LtW57LabM5qtH06hznvc3BJ7sa5XEO17n3ZHJWcfKPHf1/5hfYg1sdLU61r+Zb0muQXmZ33L8hPX+ljzUlbUQqyUPkEou44yPnBUtvXtqg5udf1R+51/amve+3WQGX27NkYDK5fPOPGjWPGjBlMmjSJb775hi+++AKr1YpGY/8rd/PmzXTs2JGwsDB3NqXBmc6vo1KSVCsF31xln1eIzTEDqDYcixD6eWvpEh3k3B5aEvhUpzqtxWpzJqeC+xJ8q1LdBQkdyibTOnJ8AiupoaIoCqa/fgRA1/MSVNrqldkXQojGwq2ZMBEREbRv397lP4CwsDAiIiKYPHkyBQUFzJw5k6SkJFasWMGiRYu466673NmMRsFosQck5Wb9SAl9F45ARV2SP5tfXPvAwFFJNi4mBI269KUdWjK9OLfAdMG6KHmFJsqWhatL4FRdzunJ1Z71U1qd9kJTk61nDmM7ewI0OnTdR9W9sUIIUc/qNT06LCyMBQsWcPz4ca6++mrmzp3Lo48+ytVXX12fzagXJpNrHRXH/y1WpV6KiDUVjkDFnvBqn/lTW44y+ecPHQX46dGoVShATkHVSdvnl9rPc1MRuqpUd0FCB2ePisFCbmHV5fPNjt6U2GGofQLr2lQhhKh3Hiv45vD333+7/BwfH8+XX37p6cs2OGMldVTAXrVWK1PosNkUckuGWTq1CSIlo6BOZfQdQzuOuikOapWKkAAvzuYayMozEh5Ueaa6I3DSadWYLTaP11GxKQpnSpJ3q1tYzlEYrrDY7Lx/5wcqiqJg2rESS/IuAHS9x7mryUIIUa/k29JDyq6eDKDVqNGUjG9InopdbqEJm6KgVqmIiQoA6lZgzdEbElpBMq4zTyW/6jwVR6ASXdLDk1dkRlH+v707j466Oh8//v7Mmp1sZGGTTQhLgLAZFBCoIipSRW2/VqlrlZ9f7WnRulTbb3taW1v4unbxa7WutdrivlALonUDNSAghi0QAoGEJCSTdfa5vz9mPpOZZJJMQiYJ+LzO4RyYLXfujH6ePPe5z43ujKCeqKhpptnhwWI2MDwrqesn0Dajop/z0xrkKOXD+enfcG19HQDL7Msxpg7p5ZELIUTfkEAlRvQOtNaQTEprG30JVKA1KEhNsgR6g5zY0k+dnlGJkJmItjutfkDiadn+oMHt8cU0sNx72AbAmCGDos6yBTMqITUqelda5fPi+OBJ3F9vAMB61gqs0y7s5VELIUTfkUAlRlye8BoVCD2YsO8Claq6Fl58b1+73TUDgR4UpKVYgxfanp734/Mp6hr9F+2IGZVkfedPV4GK//7s9IRgYNlRlmfTzko+3VnRo/Hq9pb7+8iMG54a9XOCxbR2D/VNrTUqyuvGseGPePZ9ApqBuIU3Ypn0rRManxBC9LeY16h8U+mHD1pDWpr3x3k/64vKeW9LOVazkUvmj+6znxsNPShIT45jUGB7bU932dianPiUwmjQIhaW6hmVaJd+0pKtJCeYcdZ7aWhxk5UW/rgWh4cn396FTykmnJbeo4MLlVLBjEr3AhX/f7Y+pbDpNSpmD/Z3/hdvxW4wmIg752bMI6d3e0xCCDHQSEYlRoI1KhGWfvqyRkU/CbirC3R/CAYFIRmVnhbT1oYsIxkM7c8K6m5GJS05ZEwRdv7U1NvxBWpX9pXbejTmmnoHdY1OjAaN0UOi35FjMRsxhwTAqYZmLO8HghRzHPHnr5IgRQhxypBAJUb05R2ruX9rVPSGZfVNsd9m2111Ta1BgV4Mand6erR9W9/xk9ZBV9toMir+DEVIoJLgD1QiNX0LDXj0rEh36c8bmZMc9j2JRCkfPkdjsLBXz6rkGutYNWgdqu4IWkIqCRfdjWnoxB6NRwghBiJZ+okRPRiJWKPShxmVhsBSim0gBioNrUs/iXFmDJqGTyma7G5Sk7q3lFIbfK3Iz9PrVhpb3Lg9Xsym9oFBU4sbj1ehAalJ/qUfaJ3DUMdDutzuPVzf7v5o6JmYrpZ9lFI43v8LnpJNaHHJGDJP4zyrhXK3mYvitxKvuTGkDiH+/FUYknt+ArkQQgxEEqjEgFIqpIV+6wVRr1Fx9GFGRV+20BuDDSShGRWDQSMpwUxDs4vGlh4EKo16D5XIGZXEOBMWswGX20dto5PstPYHH+rLPsmJFkxGQ6dLP6GBypHqJpod7qg7y+r2BAKc07sIVNx7PsRTsgkA5WjEW76TMwECBy1XGIdw+rKfosVFt71ZCCFOJhKoxIAr5JAmS0gtQXDpp48yKh6vjxan/3DExhY3Hq9vwDSaU0q1FtMGlmWS4/2BSlMPeqnUdZFR0TSN9OQ4KmtbqG3oPFDRC2OTO1n6CT1MUQH7yuuZNjb6bEZ9s4tjtS1owOkh5xK15a07ivPTvwFgmbkc07DJeGsO8tUXW4hrruSgJ5OKkRcwToIUIcQpSgKVGHCFZEz6s0al7Q6ahmZXhxmHvtbs8ODWTzcOBAZJgaWWnhTUdpVR8d9nDQQqketUghmeQDYnRR9PJ0s/yQlmGlvc7Dts61agsi9QnzJ0cGKHmRjlceHY+GfwuDAOnYSlYCmaZsCYNZrtpbl8XOHfGn1eUvugSwghThUD49frU4weiJhNhrAdKJ3VqOhdWntT23NqulOn4nR7aXF4enU8ofTsRVK8GUugXkQvXu3JFuVgjUpKx0tGwZ0/HfSUCe3rAv4lIIh83o8eqJwxIRuAvd3c+RPNtmTnZ//Ad/wwWlwycQt/gKa1/ueaGN/6O8agxO5vjRZCiJOFBCoxoPdQCV32gY5rVEorGvjxox/z6NodvRqstF2yqO/iQL5QD7y0jTsf+zRmh/LpQUHoUo2eUelu0zeP1xccpx6MRNLanbaDjEqb5aNBHSz9uD2+4C6qwkk5ABysaOxWpmxvF4W0nrIvg91l4xbcgCEh/HGhWZiODiQUQohTgQQqMaAv/YS2z4eOa1T2HLIBsH3/cdZ/cbjXxtEuoxJl0FFts7OvvJ5mh4fdh+p6bTyh2taDQGtNSHfP+6lrdKLwn6ek79SJpPW8nw4yKk16L5bwjEpTixufrzWA1JeZLCYDo3KTSUu24vUpDhxtiGq8dqeHw1VNAJw+LLXd/b6WehwfPAmAOf88TCOmtntMYshJyylJEqgIIU5dEqjEQOuBhB0EKm1+86622YN/X/vBfsoqG3tlHG2XUKLNqHx9sDb492gvvt0VOVDpWUalNuSMH01r3+xNp2dKOqxRaQzPqCTFm9DwF8uGjqm2vrUeRtO0YFZkX5T9VEqO1KMUZKXGR+xo69r6BsrZhCFjONbZl0V8Db2PCkhGRQhxapNAJQYiNXuDjmtU9EAlMc6E16d4/M2ve2VnUNsli2hrVIpLYx+o1EYKVOI7Ll6N5rU6q0+B1mZwHXWnDR6SGBiT0WAIZi5C57ImEOhkDPK/3rjArp09UQYqen3K6cPb7/bxNVTh3v0BANY530MzRs4QydKPEOKbQgKVGGjtoRJdjUpVIFC5ekkeqUkWKo638OLGfSc8Dr3/x+BU/wU1moyKz6fYVda63FN2rLFHnWK7YmsTFEDo0k/PMippndSnQGumpMXpwe4MLxS2Oz3Bow1Cg6dIvVT0rckZgcBI74Oy/2h9VHMVLKSNsOzjLHoVfF6MwyZjGjKhw9fQi2mNBi1sGUgIIU41EqjEQKSutBC5RsXnU8EL36jcFH6wdCIa8J9tR9myp+qExqF3VB2elQxEV6NSdqyRZoeHeKuRBKsJt8dHeXXTCY0jktADCXWtSz/dq1GJNqMSbzURbzWFPaftayRYTcRZWpdVUiJ0p9UzMhmBDM2QzEQS40y43D4OHet8rtweL6UV/ixV20Jab+1hPCWbAbDOirzko8tOSyAl0ULeiFQMnSx3CSHEyU4ClRhwdbX0E5JRqW1w4PUpTEaNtGQrE0amc37haQA8vW53xGZj0dKfOzzL3wwsmozK14Fln7wRaYwKHJQXi+Wfzotp3cEzbaJ6reDW5K57xHS088cWYTyhYwr9HI63WfoxaFqwKLarc38OHG3A41UMSrSQlRYfdp/z85cBhWn0LIyDR3b6OvFWE6v/35n8+LvTOn2cEEKc7CRQiYHg9uQ2Sz+RMip6fUrGoPhgz5WL540iNyOBZoeHXQd7vuumsU2g0tAcvnslkuJAIe2kUemMzo1NoOJ0eYMdcyMV03p9qlsnTOtLPxldZFSg414q+k6etoFKSoSdSK1LP62BkZ4d6SpQKa9uBmD0kJSwwl9v5T68h7aBZsA6c3mX7wMCfXokmyKEOMVJoBIDHRXT6ksKoRkVvT4lK7X1t2uT0cCYIf5Cy2N1LT0ag1KKhmb/csWwwYlo+E8H7qzrq9PlZV+5//yZSSPTGTM0NoGKvg04zmIMLsWAf6lMn7PubFGujbCM1JHgKcodZFRS22ZUEgNLP4G59CkVDGoiBSr7ym2d9sLRg5zMQa2ft1IK5xdrATCPn4shNbfL9yGEEN8U0kI/Blxd1Kh4fSp47k61zX/h0gtedfqyQFWdnZ5wuLzBws5BgZOAG1rc1Dc5O9wlsuewDa9PkZESR1ZaPAmBLbCVtS09OnSvI3UNkbMX4O9U63R7abS7yUrr+rWcbm9w63BXNSoQukU5PKMSujVZeVy4vnwTTBbSzeOB1sCpodmFx6tIMzSTuPdt7E01YDCRoxn4TlIVLV4TlaVDGTJ6TMSfXxMh++Mt/wpvxR4wmrBMv7jrNy2EEN8gEqjEQIfFtJbWBJbD5SUp3hBc+gnNqABkp/vPb+lpRkWvqbBa/FmKQUlWGlrc2JpcjMiO/JzWZZ80NE0jOcFCVmo8VTY7pUcbmDw6o0djaSvS1mRdUoKZ4w2OqHf+6AGGtU12piOtTd/CMyr6mLItLbS8fh++42UA5Gsm/ithJPubZgFTqD+4m6sTP2SapQzPtvDMyVmB+M+7cS9u33WYxxa2+/m1IfUtyuPCtfPfuL58GwDzpHMwJKVH9b6FEOKbQgKVGOhoe7LRYMBkNODx+nC6vCTFm4NLP4PbBiqBjMqx2p5lVBoDSxX6rpVBSRYOV3VeUKs3eps4svViOXpIClU2Owd6MVCxNXUcqAR3/kQZqETb7E2nz/OBow00triCxbK2RidjTZVMKH4Zn7sZLS4ZLTkTqkuZE1fCHGcJTX/fQHpjNemBYRuHTMA0fIq/8NfnYc/BanwVexhjrsKx8TG8lXuxzrkirBfK8XoHGooh9dtpfmkdqtk/54bBo7AWXBTVexZCiG8SCVRioKMaFfDXZTTZfcFeKjV6oNJmB4i+9NNkd9PicJPQzWWX+sBWZL0YVG8Lb+sgULE1OTlS3YxGeKAyakgKm4uPcaCi9+pUOsuo6E3fou1OW9vFjh9f/TE8B7egXHaU28lwt4OVGUepthv5el05M2dNwpCSTV7LFpYkf47RrTBkjiR+8a1oienU7NvJrn+vZar5EIbGanyakS8cI6kdchbfWboo7Ge1xFXyxN7TuDJ7NzPdRbiLN+KtLiXuzCtRjkbctRWcp75kdEoVSdvqUYCWmI511qWYTp8TduigEEIIPwlUYqCjpR/wZ1ma7P46lmaHm+bACcWDB4UHKnEWE4OSLNQ3uThWZ2dUbvcCFb2mQm9Ylho4D6ajXir6ss+InGSSQhqI6UW9B442oJSKKmvRldatwO2Di+6e9xOaUWnLW3OQlrd+B67wrNQEYEIccHwP9n+tB+BCvWxn9BwSFlyLZvLfkDhiAk83nU2aoYlfX5zFWyVm1u2o54KM09r9vKzUBHwYeKulgHkXzcX+/l/wVZfS8vqvg485S3/L5ngsBUuxTD43+LOEEEK0J4FKDHTURwXAajEBThwub7A+ZVCipd0BhgDZqfGBQKWFUYGtwtHSa1T0C/+gRP+FvL6DNvpfl/q3QU8aGV4jMTwrCZNRo8nuptpmJystoVvjiKTTGhW9jX60GRX9FOY2GRVv7WFa3l4NLjuGjBEYc05HM8eByQomC5u3lmBoquK0BAep1ONye1nnnM6Vi36AZmjNbMRbjZiMGnXeJFqyp1GxYy/Q2kMllF4QXdfoRA0pJHH5L3H850m81aUYUrJoMqXz0UEvrvjB/NcVl2CIS47qPQohxDeZBCox0FEfFQjvpaJnDdrWp+iy0hPYW15PVQ/qVII1KoHttXpGJVKNilKK4rJAIe3I8K02ZpOBEdnJHDjawP6jDb0SqASbvSX1Ro1K+EGCAN66o9jf+j04mzFkjSbhgp+gWcLneMTgBn71TBFaE3zvnNP5+4Y9ZKYlYjCEf2Z6UXFdo5OGFhc1EXqo6JLizcRbjdidXmrqHeRmZJKw9M7g/Vu3H+WdXbuZlJMuQYoQQkRJFsVjwOXpvEYFwOH2BDMqHQUqwYLaHuz8aZdRCdaotM+oHK1ppr7JhcVkYGyE82d6s/Gbx+sLnpuTFmE7cVJ8YOknyjb6re3z/YGDr/4Y9rd/j3I0Ysg4jYTzb2sXpID/uIJZeVko4OUPD+DDEDFwgtY6n4ZmV2tX2ghj1zQtuIQXaVt563O77vcihBDCTwKVGNA7z0Zc+gnc5nL7QgKV1guXUgpv7WFcO9YxyfYh2QYbx3rQSyVYo6IX0wZqVeqbne3a0xcHut+OG56K2dT+KzG6Fxu/2RqdKMBk1IKFs6H0jEq025ODNSopVrx1R2l563eoFhuGtGHEX3g7mjWxw+cunz8ao0FrPYywgz4setO3Y3X24GGGkZZ+oLUoWv9sQ7VtvS+EEKJrsvQTAx01fIPW8378NSr+C1dWihn3/s/wHNqBt3wnyu7vDpsB/DQVdjcPw3MkAeOQCVEXs+qH6IVuTwbweBXNDk9Ywez+o/6f1/aQPN3oQEHt4apG3B5fxGAmWhW1/uxQVlpC8L04tv+L0qLXMA4eSXr6BDINXppauv5qtjhaTzxOPb6Tlk+eArcDw6Ac4i/8SZfLK9npCcyfNoT3tx4BItfMQGuwd7DSH6glxoUfXBhKz45VRQpU6jvOxgghhIis1wMVm83GAw88wAcffEBTUxPjx4/ntttuY+bMmQBs2rSJ1atXs3//fnJzc7n11lu58MILe3sY/crpae2j4muqxVn0MobUXEwjp4fUqHior7NxTtxXTNz2Gg5nSLbCaME4JA8fGt5D28kzlmN/+/cYMk7DMvV8TKNnhxV8RtIQWF5JDmRSzCYjiXEmmh0e6pucYYGKnikZPaS1YNdbexjf8cNgMJFmNDEt8RiNTsXRfbsYPjwHzZoEJku3dwEdrfGfdTMkw1/r4ireiPOTFwDwlBdjLS/mZ6lwzJtCy8dlmHNOx5g9Bi0ps93Pqm10YMDHxcnb8XzwlX/qcvOIO+dmDPHRFR8vO3Mkn35VidPt7XLp52BFI9D50o0eqNTYHO3ua3vqshBCiK71eqCyatUqqqureeCBB8jIyOC5557j+uuv59VXX0UpxU033cS1117L6tWr+eCDD7jjjjtIT09nzpw5vT2UfqGUwuVqzag4N7+I58DnALg+X8t55gxS4nMZUb6HQuMW4hI84PT30zCPLcQ4bLJ/h0qgSdiv//A20307mJtwAN/xMhwbH8Ow9XUs05dhGn1GxIDF6/PRHNg1k2IBz5FijFmjGZRkpdnhwdbsYuhg/2Mbmv0Fohr+ug3vsRKcX76J99D2sNe81gpYgY/+TbN+o9GElpCGMWccpiF5GHPzMKQM7nR+goFKZiLukk04P34OgEGzl+Iyp+As/RL3kd1kGxvwFr+Ht/g9ALT4FIxZY9BSsjAkpqIlpNFSp7EyeQPjzZUAmKcswTr7cjRD+0xWRwYlWblq8Tg2bCln+rjIY9e3eFcGskGdLd1kdZBRCTsjSJZ+hBAiar0aqJSVlfHJJ5/wwgsvMGPGDAB+9rOf8dFHH/Hmm29y/Phxxo8fz49//GMAxowZQ3FxMU888cQpE6i4PT70ChBLSzWeA18A/i6m3sq9JLmPc278cagHNKjwpjJy0WWYxxaiGdt/HOa0XNYejidz/neY6tuJ66t/47NV4Nj4fxi2BAKWMWeEXZyb7B4UMNRYi+Hd32C3HQWTlYsNo/m3aTj1ja0X0QNHG7DgZkZGE2rDA7QcKfbfoWkYc8YBoLwe6huaaW62k2Rwk2hwoikveD2oxmo8jdV49n3if1pSBqbRs7FMPT9iVkMPVMZpZTjefw5QWPPPIf2ca7DZWjBNWsxPHn6P4Z4yvjdVI77xEL6aQyh7A56yL8NeKxfINYMbM8nfugHzmDO6/4EBZ+XnclZ+xwcB6nUzus4zKv77qm32sL4z9U3+M4I0rbX5nhBCiK71aqCSlpbG448/Tn5+fvA2TdPQNI2GhgaKioo455xzwp5TWFjIfffd12vNxPqbK7DsA8DX6wCFccQ0Epb8COVqoWjjRlr2FRFnVnzYPJaGlNP51fj2Z8LostLi2XPYxtFGjdnzvo1l8mJcO9fj+updfPWVON5/HG3r61gLlmEaW4hmMNLY5GCBtZiLEraibD7QjOBxMp5djE/ZhWPLF9grRuNrOs7wumOsTreDAu8RQDNiHncmlmkXYhiUExxHU10LDz1dFCgmVQxNM3P+1HSm53rRju3DU7EbX1Upquk47h3rcBe/h2XSOZinnh+sFVFKcfR4E3nmIwzb/R9QPkynn0X83KvCPntLQiLbjo/k3NMLmHBaGsrjwltThq/mIL6m46hmG6qljsaaKipazJSOWMYlPQxSopHS5hDHjrrg6vcZNA23x4etyRWse6kNOYjRZJQadiGEiFavBiopKSmcffbZYbe9++67lJWV8dOf/pRXX32VnJycsPuzsrKw2+3U1dWRnt7zA9lMJ1DgGUnxxneI2/0OyVMWkVm4NOruoR6fP58y2NSMd/9mABJmfds/PlMSzTkFPLuttRdJQUZCp2PPzfTvWqm2OQKvkYh59sUkTDsPx1cbcG5fh6o/huODv2DY+jpx0y7AWryZSxJ3A2A+bRoJC2/AV1/Jro1vk2nbSZyrDs/BLQDo78pjiicx70ysBRdiTM5sN46hg5NYffOZbCg6zPqico7UuXnigyrSU6zc+/2LyDzzOyi3E/fhnTi2vIG3uhTX9ndwff0elnFzUM4WXLUV/DKhAqvmAR+YR80g8Vs3YDL5v4bGwAU8JcFCxfEW7E5P4D3HYR42HoaNDxvTi298zcc7Krhs8PBe//xDtS2yzUqP7/DnmUwGMgbFUW2zU9voDO4Cqgv0r8kc1PFz+4o+z0YJmGJO5rrvyFz3nb6e65ju+tm6dSt33303ixcvZsGCBTgcDiyW8Au+/m+XK7q+GZEYDBppaR1vQ+2J+upj5NIAO16j8eDHpC/4HkmT53V5HkuTy59ROTfha/B5iR81hcF5U4L3p6eGN0wbnpPS6djHDPc3YDve6GjzuETI/i98879Nw5Z3sW1+HV9DFS0fPk0c4FJGihLP5sorb/ZnK4bm8mlNCg+//iWXnd7MBTMyMaYM5p7n9nDUEcfvVy1maGB3T0fS0hK5flga3zt/Ius/K+OVD0o4Xu/gjU/LuO3KGf4xZc1HTZ9HS8kW6j58CVflAVzFHwCgAVYNvBhImTiHrItuRTO1LqukpMQH5igeDtvw0Pnnqu9sGp47qNc//1DeNp/5qGFpnf68oYOTqLbZaXZ5g49rCXwvcjOTYjrW7tDnW8SezHXfkbnuO3011zELVDZs2MDtt9/O9OnTWbNmDQBWq7VdQKL/Oz6+52/Y51M0NHS/KVpnGkcu4tkyN5embCexoYbqNx6hdtMbxM26BPPwyWEn4oaqPt5EitbCDOM+AIxTLqSuLlh+isftCXv8oHhz2P1tJVn9tSdHqpo6flzeuaSMmY/z6404tq2jkQQerZjJabnjsdla58ViABdmtjhHsmTsTA5XN3HAXoHFbCDZauh0HG3Ny89h+OAEfv7E53ywtZxF04cwMiekJiVzAgmX/A/mg1/iObILQ1I6244Z+eeWJkadPopbFhRga3QBLoxGAykp8TQ02PF6fcQFMg5VNR2/Z4/Xx9HqJgDijHRr7N3lC13OAyya6vTnpQW2gh88YqNurP/E6fJj/p1VKfGmmI41Gm3nW8SOzHXfkbnuO7011ykp8VFlZWISqDz//PPcd999LFmyhN/97nfBrElubi5VVVVhj62qqiIhIYHk5BNrKe7x9O4Xc2hWMs+7RlPpHc+9s+txbXsLb/VBmt95EMxxmIZPwTRqBqbhU8I6n7bY3SyKK8akeTFkj4WscWFjM7f5UDJSrJ2OXW8N3+zwYGsM31YcRjNjmnweiZMW8+5/9lNZfohJ8eaw19YbrNkanXg8PvYetgEwMicF5QOPr3tzOCwziTMmZvNZ8TH+8V4Jq747rd1jDMOnYRnuv33n4V1U+yoozEiO+J69Xh8ej4+EOP/Xsr7ZFfFxLreXP7+2k5p6Byajgez0hF7//ENpQLzVhN3pwWwykGA1dfrzMgO7eiprW4KPqw407UtN7vzz7kv6fIvYk7nuOzLXfaev5rrXA5UXXniBX/3qV6xYsYJ77rknrEhy5syZfP7552GP37x5M9OnT293xkp/G56VBMDROjdq0hIS8+bj+vItPAc+R7XY8Bz43L/t2GDCdNo0zOPnYRw2GU9LA2fG+Q+usxYsa1cg3LZbbUft80Mfn5Zspa7RybHaFpKGdr48o2lau2ZvutQ2bfQj9U/prkvmj6ZodxU7S2spPljLxJEd1xkdrfFnd4YO7nzpo7MTlFscHh55eQd7D9swmwz8v4snB/ucxFJKghm700N6SlyXRd/6Zxranfa49FARQoge6dXooLS0lN/85jece+653HTTTdTU1FBdXU11dTWNjY2sWLGCHTt2sGbNGvbv389f//pX/vWvf3HDDTf05jB6RUqihbRkKwo4UtOMIT6FuDO/R+KVD5Dw7XuxTL0AbVA2+Dx4Souw/+tBml+4jcxtT2HVPFRpgzEOz2/3unEhpyRr+Isru9LdM3/09vPJbXar6N1pnW4vdqenNVDp5snMobJS41lQMBSAf36wH1+b9vw6pRRHgs3eughUApmfpjYnKDc0u/j937ey97CNeKuRVd+ZyrSx7Qt/Y0Gfy2i6ygYDlbrQQEV6qAghRE/0akbl3Xffxe12s379etavXx923yWXXML999/Pn/70J1avXs0zzzzDsGHDWL169YDtoTIyN4W6xmrKq5oYEyg01TQDxuyxGLPHYpl9Ob7jh3Dv/RjPvk2oFhsJ2ADYFn8GYyL85h2aUUlLsUbVjj4rLYHdh2wRD7qLRD+QcFCbTEOcxYTVYsTp8lJVZ6c8UOMxpossTVcuOnMkH39VQVllI0W7q5g9IbvdY2xNLuxODwZNIzu98xOYkyKc91NSXs+T7+ziWG0LyQlmVn1nGqfl9N0JxHrWJpqMiB6oNLS4cbg8+Hy0nhEk7fOFEKJbejVQWblyJStXruz0MfPnz2f+/Pm9+WNjZuSQQXy5t5ryqsjFj5qmYcw8DWPmaagzvovn0HaOFm2kuMJNRca4iM+xhmRUBkeRTYHQjEqUgUqb9vmhUhMtHHPZ2bG/BqX8W287OuMmWimJFs6fPYLXPi7llf8cYPq4we16heiN3rLS4rsMzvQGaw0tLrbtq2HdZ2XsKw+cf5Ri5bb/KiCni2Cnt+mN3HK7yAYBJMSZSIo302R3U23zd/2Fzs8IEkIIEZn8X7MTIwNLIocDmYfOaEYT5lEz2FU1mH/uL6HQErmNe2hGRe+x0ZWsNP9F+Vht95Z+2taogL9l/LE6O1v31gAntuwTavHs4WzcWk6Vzc6H24+yaPqwsPv1QGVoZtcXer1guL7JxSMv7wD8py3PmZTDxfNGn3Bg1RMXzhnJ0MwkZuZ1fkSAbnBqXCBQsWMw+EMVWfYRQojuG1gVrAPMqECRaXlVE6qD2ou2XB7/OT9ti2Z1YYFKF4W0uuz01oxKV+Nwurw4A6c3J0coMk0N1KmUHfMfsHcihbSh4iwmls0dBcC6zWXtalX0+pTcKAKVlAQLxsDFPd5q5PwzRvC7lWdy7QUT+iVIAX/wNHdKbtQZkeApynX2kFOTJVARQojukoxKJ4ZlJWE0aLQ4PdQ1Ojttna7TgwSLKXKgYjBoWEwGXB5f8AC7ruiPszs9NNrdne5y0XfKmE2GsMJd3aDE8At9bwUqAHPzc3n5P/s53uBk32Eb40ekBe87ejz6jIrFbOT6CyfQaHdz1uTc4Hblk0mwoLbeTlwgOJVARQghuk8yKp0wm4zkZviXXQ5Xdb38A+By+/eUWy0dT2184MKbFeXSj8VsJD1QhNlVQW3o1uRI22hTk1uDHE2jVwtSLWYjM8ZnAbDp62PB25VSVIScmhyNwkk5nDtz+EkZpEBrcFldZ5cdP0IIcQIkUOnC8Cz/hbw8ijoVaM2odLT0A/DdhWM5v3AEI7sRJOgXvq7qVPQdP5GWfQBSQzIqQzOTer24c84k/1lOX+yuwh1YBqtvdtHs8KBpkJP+zWhvHdpLRZZ+hBCi5yRQ6cLwbH/jt+gzKp0v/YA/W3D5grHdOi1a39Lb1c4ffcdP2xN/dXovFYAxQ3tv2Uc3fkQqaclW7E4PO/YfB0J3/CRg7mReTiV6tqym3kF1vWRUhBCipyRQ6YLeoba8OrrzWVqXfnr3gpwd2PlT1UXTt8ZgRiVyq/1BSa0Zld7a8RPKoGkUTvT3UdGXf1obvfXtluL+lJpkxWTU8PpUMHiUjIoQQnSfBCpd0AOVyuMtwaWMzrQW0/bu1Oq9VPaV12Nrcnb4uIZmvUalg6WfkIxKbxbShtKXf3bsr6HJ7g7Wp3TVOv9UYjBoYV2HzSZDh8GjEEKIjkmg0oW0ZCuJcSZ8SgXPqgnVdruwK4oalZ4YPyKN1CQLdY1OfvPclg4zK41d1KgkWE3MnpBFwemZUW0V7olhWUkMG5yEx6so2lMVdev8U03o9vNozggSQgjRngQqXdA0LWT5J7xOZdPOSn748Ee8s7ksGLAEMyq9vPSTEGfirqtmMDg1jpp6B799fivlEepm9GLalMTIv71rmsbKb0/m1kunYIjhhXPO5MDyz87KYI1KtDt+ThWh288zpXW+EEL0iAQqURg6uH1BbYvDwwsb9tLs8LD2g/384/0SlFKtu35iUDSalRrP3VfNYNjgROqbXdz/t62UBFrL67pa+ukrZ0zIRsO/VNW64+ebU6MCrW33gah68AghhGhPApUo6BmVIyEZlXWfldHs8ATbvb/7+WGeemc3Dlcgo2KOzdSmJlm588rpjBmaQovTw5qXvuSVDw8ECza7WvrpK+kpceSd1trwbXBqPJZeXg4b6EKPSJAdP0II0TMSqERhmJ5RCez8qWt0sv6LwwBce34e116Qh6bBx19VBM/Z6e0alVCJcWZu/24Bk0en43L7eOvTg/zkz5/y3L/3tJ7z08H25L5UOKn1FOVoOtKeakJrVGTHjxBC9IwEKlEYmpmIhr9HSX2zizc+KcXl8TF26CCmnZ7JvClDuPnifEzG1pqPWGcPrBYjP7psKjdfPJlRucm4PT7e33okeMbOQNhhMmNcVvCk5G9afQqEn44tgYoQQvSMBCpRsFqMwQZeRbur+Gh7BQCXLRgT3MkxY/xgfnT5VKwWI4lxpuCSUCwZDBoz87K49/sz+ckVBUwelQ74m8OZjP3/0SbEmZgTyKqELgN9U1gtRoYNTsRsMjDkG7Q1WwghepOmoj0WeADzen3U1kbXkC1aJpOBtLRE6uqa8Xh8/PHVr9iypzp4oOC0sZn88LIp7Z7X0OLC51OkJvXPLo+quhbirKZ+L6bVebw+auodnRbStp3rU0mzw43d6QnrqdLfTuX5HmhkrvuOzHXf6a25Tk9PxBjFL9X9/2v3SWJ4oE7F5fGhaXDp2aMjPi4lwdJvQQr429QPlCAFwGQ0fON2+4RKjDMPqCBFCCFONhKoRGlYYOcPwFn5ucEty0IIIYSInd49OvcUNjInGU3zZwgunjuqv4cjhBBCfCNIoBKl9JQ4fnT5VBLiTNK8SwghhOgjEqh0Q/7ojP4eghBCCPGNIjUqQgghhBiwJFARQgghxIAlgYoQQgghBiwJVIQQQggxYEmgIoQQQogBSwIVIYQQQgxYEqgIIYQQYsCSQEUIIYQQA5YEKkIIIYQYsCRQEUIIIcSAJYGKEEIIIQYsCVSEEEIIMWBJoCKEEEKIAUtTSqn+HsSJUkrh8/X+2zAaDXi9vl5/XdGezHXfkvnuOzLXfUfmuu/0xlwbDBqapnX5uFMiUBFCCCHEqUmWfoQQQggxYEmgIoQQQogBSwIVIYQQQgxYEqgIIYQQYsCSQEUIIYQQA5YEKkIIIYQYsCRQEUIIIcSAJYGKEEIIIQYsCVSEEEIIMWBJoCKEEEKIAUsCFSGEEEIMWBKoCCGEEGLAkkBFCCGEEAOWBCoR+Hw+HnnkEebNm8e0adP4wQ9+wOHDh/t7WCc9m83Gz3/+c+bPn8/06dO54oorKCoqCt6/adMmli9fztSpU1myZAlvv/12P4721FFaWkpBQQGvvPJK8LZdu3Zx1VVXMW3aNBYtWsSzzz7bjyM8Nbz22mtccMEF5Ofnc+GFF7Ju3brgfeXl5dx0001Mnz6duXPn8tBDD+H1evtxtCcvj8fDww8/zMKFCykoKODKK69k27Ztwfvlu907/u///o8VK1aE3dbV3Mbs2qlEO48++qg644wz1Pvvv6927dqlrrvuOrV48WLldDr7e2gntWuvvVYtXbpUffHFF+rAgQPql7/8pZoyZYrav3+/KikpUfn5+eqBBx5QJSUl6oknnlATJ05Un376aX8P+6TmcrnU8uXL1bhx49TLL7+slFKqtrZWnXHGGeruu+9WJSUlau3atSo/P1+tXbu2n0d78nrttdfUxIkT1fPPP6/KysrUn/70J5WXl6e2bt2qXC6XWrx4sbrxxhvVnj171Pr169Xs2bPVww8/3N/DPik98sgj6qyzzlIfffSROnjwoLrnnnvUjBkz1LFjx+S73Uuef/55lZeXp6666qrgbdHMbayunRKotOF0OlVBQYH629/+Frytvr5eTZkyRb355pv9OLKT28GDB9W4ceNUUVFR8Dafz6fOOecc9dBDD6mf/exn6rLLLgt7zqpVq9R1113X10M9pfzv//6v+v73vx8WqDz22GNq7ty5yu12hz1u8eLF/TXMk5rP51MLFy5U999/f9jt1113nXrsscfUm2++qSZPnqxsNlvwvhdffFFNnz5dfvnpgWXLlqnf/va3wX83NjaqcePGqXfffVe+2yeosrJS3XTTTWratGlqyZIlYYFKV3Mby2unLP20sXv3bpqbm5kzZ07wtpSUFCZOnMgXX3zRjyM7uaWlpfH444+Tn58fvE3TNDRNo6GhgaKiorA5BygsLGTLli0opfp6uKeEL774gpdeeon7778/7PaioiJmz56NyWQK3lZYWMjBgwepqanp62Ge9EpLSzly5AgXXXRR2O1PPvkkN910E0VFRUyaNIlBgwYF7yssLKSpqYldu3b19XBPehkZGbz//vuUl5fj9Xp56aWXsFgs5OXlyXf7BH399deYzWbeeOMNpk6dGnZfV3Mby2unBCptVFZWApCbmxt2e1ZWVvA+0X0pKSmcffbZWCyW4G3vvvsuZWVlzJs3j8rKSnJycsKek5WVhd1up66urq+He9JraGjgjjvu4N577233Xe5orgEqKir6bIynitLSUgBaWlq4/vrrmTNnDpdffjkbN24EZL572z333IPZbOZb3/oW+fn5PPjggzzyyCOMGDFC5voELVq0iEcffZThw4e3u6+ruY3ltVMClTbsdjtA2AUVwGq14nQ6+2NIp6StW7dy9913s3jxYhYsWIDD4Wg35/q/XS5XfwzxpPaLX/yCgoKCdr/lAxHn2mq1Ash3vAeampoAuPPOO1m6dCl//etfOeuss7j55pvZtGmTzHcvKykpITk5mT/+8Y+89NJLLF++nNtvv51du3bJXMdQV3Mby2unqeuHfLPExcUB/ouj/nfwfxDx8fH9NaxTyoYNG7j99tuZPn06a9asAfxf5rYBif5vmffuee211ygqKuLNN9+MeH9cXFy7udb/R5KQkBDz8Z1qzGYzANdffz2XXHIJABMmTKC4uJinnnpK5rsXVVRUcNttt/H0008zc+ZMAPLz8ykpKeHRRx+VuY6hruY2ltdOyai0oaetqqqqwm6vqqoiOzu7P4Z0Snn++ee59dZbWbhwIY899lgwIs/NzY045wkJCSQnJ/fHUE9aL7/8MsePH2fBggUUFBRQUFAAwP/8z/9www03kJOTE3GuAfmO94A+Z+PGjQu7fezYsZSXl8t896Lt27fjdrvDat0Apk6dSllZmcx1DHU1t7G8dkqg0kZeXh5JSUl89tlnwdsaGhooLi5m1qxZ/Tiyk98LL7zAr371K6688koeeOCBsBThzJkz+fzzz8Mev3nzZqZPn47BIF/T7lizZg3vvPMOr732WvAPwA9/+EPuu+8+Zs2axZYtW8L6eGzevJlRo0aRkZHRT6M+eU2aNInExES2b98edvvevXsZMWIEs2bNori4OLhEBP75TkxMJC8vr6+He1LTayT27NkTdvvevXsZOXKkfLdjqKu5jem184T2DJ2iHnjgATV79my1YcOGsL3gLperv4d20jpw4ICaNGmS+u///m9VVVUV9qehoUHt3btXTZo0Sa1evVqVlJSoJ598Uvqo9KLQ7ck1NTVq1qxZ6s4771T79u1TL7/8ssrPz1evvPJKP4/y5PXHP/5RFRQUqDfffDOsj8rmzZuVw+FQ55xzjrr++uvVrl27gn1UHn300f4e9knH6/WqK664Qi1ZskRt2rRJlZaWqgcffFBNmDBBbdu2Tb7bvejOO+8M254czdzG6topgUoEHo9H/f73v1eFhYVq2rRp6gc/+IE6fPhwfw/rpPbnP/9ZjRs3LuKfO++8Uyml1H/+8x+1dOlSNXnyZLVkyRL19ttv9/OoTx2hgYpSSm3fvl195zvfUZMnT1YLFy5Uzz33XD+O7tTw17/+VS1atEhNmjRJLVu2TK1fvz5438GDB9W1116r8vPz1dy5c9VDDz2kvF5vP4725GWz2dQvfvELtWDBAlVQUKC++93vqs8++yx4v3y3e0fbQEWpruc2VtdOTSlpUiGEEEKIgUkW/4UQQggxYEmgIoQQQogBSwIVIYQQQgxYEqgIIYQQYsCSQEUIIYQQA5YEKkIIIYQYsCRQEUIIIcSAJYGKEEIIIQYsCVSEED1WWVnJlVdeSX5+PnPmzAke9S6EEL3F1N8DEEKcvJ555hm2bdvG6tWryc7OPuHj3IUQoi0JVIQQPWaz2cjKyuKCCy7o76EIIU5RsvQjhOiRRYsW8corr3D06FHGjx/PihUrGD9+PC+++CILFy5k+vTpfPLJJwD885//ZPny5UybNo0pU6bw7W9/m3Xr1gVf65VXXiE/P5+ioiIuvfRS8vPzOe+889i4cSMHDhzg6quvZurUqZx77rm8/fbbYeM4evQoq1atYvbs2UydOpWrr76a4uLisMe89dZbLFu2jClTplBYWMjtt9/OsWPHYj9JQogTJocSCiF6pLi4mIceeoji4mL+8Ic/UFZWxh133MHgwYO59957cTgcLF68mFdffZVf//rX3HrrrcyYMYP6+nr+8pe/UFxczHvvvUdOTg6vvPIK99xzD1lZWdxyyy3k5uayZs0aDh06RGZmJldccQV5eXn84Q9/YPv27WzYsIGcnBxqa2u5+OKLiY+P55ZbbiE+Pp5nnnmGnTt3snbtWsaMGcOWLVtYsWIFN998M7NmzaKyspLVq1czcuRInn/++f6eRiFEF2TpRwjRIxMnTiQ9PR2LxcK0adNwOp0AfO9732PJkiXBxx0+fJjrr7+em2++OXjb0KFDWb58OVu2bOHCCy8EwOfzsXLlSi6//HIAGhoa+PGPf8zVV1/NtddeC0BycjKXXnopO3fuJCcnh2eeeQabzcbf//53hg4dCsD8+fO54IILePjhh3nkkUfYsmULcXFx3HjjjVgsFgBSU1P56quvUEqhaVrsJ0sI0WMSqAghetWECRPC/n3XXXcB/sDjwIEDlJWV8dlnnwHgcrnCHltQUBD8e0ZGBgBTp04N3paamhp8LYBNmzYxYcIEsrOz8Xg8ABgMBubPn88bb7wBwKxZs3jwwQdZunQp5513HmeffTZz587l7LPP7q23LISIIQlUhBC9KiEhIezfhw4d4uc//zmbNm3CbDYzevRo8vLyAGi78pyUlNTu9TrbSWSz2SgrK2PSpEkR77fb7RQUFPD444/z9NNP89RTT/H444+TmZnJypUrWbFiRXffnhCij0mgIoSIGZ/Px4033ojZbGbt2rVMmDABk8lESUkJr7/++gm/fnJyMrNnz+aOO+6IeL++1DNv3jzmzZuH3W5n8+bNPPvss/z6179m6tSpTJky5YTHIYSIHdn1I4SImbq6OkpLS7nsssvIz8/HZPL/bvThhx8C/kDmRMyePZvS0lJGjRpFfn5+8M/rr7/O2rVrMRqN/O53v+PSSy9FKUV8fDwLFy7kzjvvBPw7hoQQA5tkVIQQMZORkcHQoUP529/+Rk5ODikpKXz00Uc8++yzACfcyfaaa67h9ddf55prruG6664jLS2Nd955h3/84x/cfffdABQWFvLUU09x1113sWzZMtxuN0888QSpqakUFhae8HsUQsSWZFSEEDH1pz/9iezsbO666y5+9KMfsX37dv785z8zevRoioqKTui1s7OzefHFFxk6dCi/+MUvWLlyJTt27OC+++7jmmuuAeDss89mzZo17Nu3j1tuuYVVq1YRHx/Ps88+GyzOFUIMXNJHRQghhBADlmRUhBBCCDFgSaAihBBCiAFLAhUhhBBCDFgSqAghhBBiwJJARQghhBADlgQqQgghhBiwJFARQgghxIAlgYoQQgghBiwJVIQQQggxYEmgIoQQQogBSwIVIYQQQgxY/x++gX9MFFBaYQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_curve(cfg, range(len(res['rewards'])), res['rewards'], label = \"rewards\", title = f\"{cfg.mode}ing rewards on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "for k, v in res['policy_summary_dict'].items():\n",
    "    plot_curve(cfg, range(len(v)), v, label = k, title = f\"{cfg.mode}ing {k} on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "plot_curve(cfg, range(len(res['eval_rewards'])), res['eval_rewards'], label = \"eval_rewards\", title = f\"online eval reward on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "joyrl-book",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
